solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int logar2[400000];
void precLogar2() {
for (int i = 2; i < 400000 - 5; ++i) logar2[i] = 1 + logar2[i >> 1];
}
struct RangeMinimumQuery {
int n;
int **table;
int dims = -1;
vector<int> a;
RangeMinimumQuery(int n) : n(n) {
a.clear();
for (int i = 0; i <= dims; i++) delete table[i];
delete table;
dims = 0;
};
RangeMinimumQuery(){};
void init() {
a.clear();
for (int i = 0; i <= dims; i++) delete table[i];
delete table;
dims = 0;
}
void Push(int x) { a.push_back(x); }
void buildtable() {
n = (int)a.size();
dims = logar2[a.size()];
if ((1 << dims) < a.size()) ++dims;
table = new int *[dims + 1];
for (int i = 0; i <= dims; ++i) {
table[i] = new int[n];
}
for (int i = 0; i < n; ++i) table[0][i] = a[i];
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 0; i <= n - (1 << j); i++) {
int tem = min(table[j - 1][i], table[j - 1][i + (1 << (j - 1))]);
table[j][i] = tem;
}
}
return;
}
int RMQ(int L, int R) {
int j = (int)log2(R - L + 1);
if (table[j][L] <= table[j][R - (1 << j) + 1])
return table[j][L];
else
return table[j][R - (1 << j) + 1];
}
};
const int MAX = 300100;
char txt[MAX];
int iSA[MAX], SA[MAX];
int cnt[MAX], nxt[MAX];
bool bh[MAX], b2h[MAX];
bool smaller_first_char(int a, int b) { return txt[a] < txt[b]; }
void suffixSort(int n) {
for (int i = 0; i < n; ++i) {
SA[i] = i;
}
sort(SA, SA + n, smaller_first_char);
for (int i = 0; i < n; ++i) {
bh[i] = i == 0 || txt[SA[i]] != txt[SA[i - 1]];
b2h[i] = false;
}
for (int h = 1; h < n; h <<= 1) {
int buckets = 0;
for (int i = 0, j; i < n; i = j) {
j = i + 1;
while (j < n && !bh[j]) j++;
nxt[i] = j;
buckets++;
}
if (buckets == n) break;
for (int i = 0; i < n; i = nxt[i]) {
cnt[i] = 0;
for (int j = i; j < nxt[i]; ++j) {
iSA[SA[j]] = i;
}
}
cnt[iSA[n - h]]++;
b2h[iSA[n - h]] = true;
for (int i = 0; i < n; i = nxt[i]) {
for (int j = i; j < nxt[i]; ++j) {
int s = SA[j] - h;
if (s >= 0) {
int head = iSA[s];
iSA[s] = head + cnt[head]++;
b2h[iSA[s]] = true;
}
}
for (int j = i; j < nxt[i]; ++j) {
int s = SA[j] - h;
if (s >= 0 && b2h[iSA[s]]) {
for (int k = iSA[s] + 1; !bh[k] && b2h[k]; k++) b2h[k] = false;
}
}
}
for (int i = 0; i < n; ++i) {
SA[iSA[i]] = i;
bh[i] |= b2h[i];
}
}
for (int i = 0; i < n; ++i) {
iSA[SA[i]] = i;
}
}
int lcp[MAX];
void getlcp(int n) {
for (int i = 0; i < n; ++i) iSA[SA[i]] = i;
lcp[0] = 0;
for (int i = 0, h = 0; i < n; ++i) {
if (iSA[i] > 0) {
int j = SA[iSA[i] - 1];
while (i + h < n && j + h < n && txt[i + h] == txt[j + h]) h++;
lcp[iSA[i]] = h;
if (h > 0) h--;
}
}
}
int n, m;
char a[400000];
char b[400000];
RangeMinimumQuery Sa;
int getCommon(int l, int r) {
l--;
r--;
l = iSA[l];
r = iSA[r];
if (l > r) swap(l, r);
int ret = Sa.RMQ(l + 1, r);
return ret;
}
inline bool comp(int i, int j) {
int temi = i;
int temj = j;
if (i > j) {
return !comp(j, i);
}
int len = min(j - i, m);
int mtch = getCommon(i + 1, n + 1);
if (len > mtch) {
return iSA[n] < iSA[i];
}
if (len == j - i) {
mtch = getCommon(n + len + 1, n + 1);
int len1 = m - len;
if (mtch < len1) {
return iSA[n + len] < iSA[n];
}
mtch = getCommon(n + len1 + 1, i + 1);
int len2 = m - len1;
if (mtch < len2) {
return iSA[i] < iSA[n + len1];
}
return temi < temj;
}
mtch = getCommon(i + 1, i + len + 1);
int len1 = j - i - len;
if (mtch < len1) {
return iSA[i] < iSA[i + len];
}
mtch = getCommon(n + 1, i + len1 + 1);
int len2 = m;
if (mtch < len2) {
return iSA[i + len1] < iSA[n];
}
return temi < temj;
}
int arr[400000];
struct st {
int l, r, x, y, id;
};
vector<st> smallQueries[350];
int ans[400000];
int inv[400000 + 5];
RangeMinimumQuery Choto[350];
inline void solve() {
for (int i = 1; i <= 100; i++) {
if (smallQueries[i].empty()) continue;
for (int j = 0; j < n + 1; j++) {
Choto[j % i].Push(inv[j]);
}
for (int j = 0; j < i; j++) Choto[j].buildtable();
for (st u : smallQueries[i]) {
ans[u.id] = INT_MAX;
for (int j = u.x; j <= u.y; j++) {
int l = u.l / i;
int r = u.r / i;
if (u.l % i > j) l++;
if (u.r % i < j) r--;
if (l <= r) ans[u.id] = min(ans[u.id], Choto[j].RMQ(l, r));
}
}
for (int j = 0; j < i; j++) {
Choto[j].init();
}
}
}
int main() {
precLogar2();
scanf("%s", a);
scanf("%s", b);
n = strlen(a);
m = strlen(b);
for (int i = 0; i < n; i++) txt[i] = a[i];
for (int i = 0; i < m; i++) txt[n + i] = b[i];
suffixSort(n + m);
getlcp(n + m);
for (int i = 0; i < n + m; i++) Sa.Push(lcp[i]);
Sa.buildtable();
for (int i = 0; i < n + m; i++) {
arr[i] = i;
}
sort(arr, arr + n + 1, comp);
Sa.init();
int q;
scanf("%d", &q);
for (int i = 0; i <= n; i++) {
inv[arr[i]] = i;
}
RangeMinimumQuery Boro;
for (int i = 0; i <= n; i++) {
Boro.Push(inv[i]);
}
Boro.buildtable();
for (int t = 1; t <= q; t++) {
int l, r, x, y, k;
scanf("%d %d", &l, &r);
scanf("%d", &k);
scanf("%d %d", &x, &y);
if (k <= 100) {
smallQueries[k].push_back({l, r, x, y, t});
} else {
ans[t] = INT_MAX;
for (int i = 0; i <= n; i += k) {
int u = i + x;
int v = i + y;
if (u >= l && v <= r) {
ans[t] = min(ans[t], Boro.RMQ(u, v));
} else if (u > r || v < l)
continue;
else {
u = max(u, l);
v = min(v, r);
ans[t] = min(ans[t], Boro.RMQ(u, v));
}
}
}
}
solve();
for (int i = 1; i <= q; i++) {
if (i != 1) printf(" ");
if (ans[i] == INT_MAX)
printf("-1");
else
printf("%d", arr[ans[i]]);
}
printf("\n");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool sortbysecinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
bool sortbysize(string &s1, string &s2) { return s1.size() < s2.size(); }
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortcol(const vector<int> &v1, const vector<int> &v2) {
return v1[0] < v2[0];
}
long long proceed() {
long long l, r, m, i, mn = 1e15, a;
cin >> l >> r >> m;
for (i = l; i <= r; ++i) {
if (i <= m) {
long long x = m % i;
if (x < mn) mn = x, a = i;
}
long long y = i - m % i;
if (y < mn) mn = y, a = i;
}
(m + mn) % a == 0 ? cout << a << " " << l << " " << l + mn << "\n"
: cout << a << " " << l + mn << " " << l << "\n";
return 0;
}
int main() {
int t = 1, i = 0;
cin >> t;
while (t--) {
proceed();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
string a, b;
cin >> a >> b;
long long aa[27] = {0}, bb[27] = {0};
queue<long long> q[27], v[27];
for (int i = 0; i < a.size(); i++) {
if (a[i] == '?') {
aa[26]++;
q[26].push(i + 1);
} else {
aa[a[i] - 'a']++;
q[a[i] - 'a'].push(i + 1);
}
}
for (int i = 0; i < b.size(); i++) {
if (b[i] == '?') {
bb[26]++;
v[26].push(i + 1);
} else {
bb[b[i] - 'a']++;
v[b[i] - 'a'].push(i + 1);
}
}
long long ans = 0;
vector<pair<long long, long long> > yo;
for (int i = 0; i < 26; i++) {
if (aa[i] > 0 and bb[i] > 0) {
long long mi = min(aa[i], bb[i]);
aa[i] -= mi;
bb[i] -= mi;
long long cnt = 0;
while (cnt != mi) {
ans++;
yo.push_back(make_pair(q[i].front(), v[i].front()));
q[i].pop();
v[i].pop();
cnt++;
}
}
}
if (aa[26] >= bb[26]) {
for (int i = 0; i < 27; i++) {
if (bb[i] > 0 and aa[26] > 0) {
long long mi = min(bb[i], aa[26]);
aa[26] -= mi;
bb[i] -= mi;
long long cnt = 0;
while (cnt != mi) {
ans++;
yo.push_back(make_pair(q[26].front(), v[i].front()));
q[26].pop();
v[i].pop();
cnt++;
}
}
}
for (int i = 0; i < 27; i++) {
if (aa[i] > 0 and bb[26] > 0) {
long long mi = min(aa[i], bb[26]);
bb[26] -= mi;
aa[i] -= mi;
long long cnt = 0;
while (cnt != mi) {
ans++;
yo.push_back(make_pair(q[i].front(), v[26].front()));
q[i].pop();
v[26].pop();
cnt++;
}
}
}
} else {
for (int i = 0; i < 27; i++) {
if (aa[i] > 0 and bb[26] > 0) {
long long mi = min(aa[i], bb[26]);
bb[26] -= mi;
aa[i] -= mi;
long long cnt = 0;
while (cnt != mi) {
ans++;
yo.push_back(make_pair(q[i].front(), v[26].front()));
q[i].pop();
v[26].pop();
cnt++;
}
}
}
for (int i = 0; i < 27; i++) {
if (bb[i] > 0 and aa[26] > 0) {
long long mi = min(bb[i], aa[26]);
aa[26] -= mi;
bb[i] -= mi;
long long cnt = 0;
while (cnt != mi) {
ans++;
yo.push_back(make_pair(q[26].front(), v[i].front()));
q[26].pop();
v[i].pop();
cnt++;
}
}
}
}
cout << ans << "\n";
for (int i = 0; i < yo.size(); i++) {
cout << yo[i].first << " " << yo[i].second << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
static const int MOD = 10007;
template <class T>
inline T MIN(const T x, const T y) {
return (x < y) ? x : y;
}
template <class T>
inline T MAX(const T x, const T y) {
return (x > y) ? x : y;
}
template <class T>
inline void UPDMIN(T &x, const T y) {
if (x > y) x = y;
}
template <class T>
inline void UPDMAX(T &x, const T y) {
if (x < y) x = y;
}
template <class T>
inline int SIZE(const T &x) {
return (int)x.size();
}
template <class T>
inline int LENGTH(const T &x) {
return (int)x.length();
}
template <class T1, class T2>
inline pair<T1, T2> MP(const T1 &x, const T2 &y) {
return make_pair(x, y);
}
inline int BINT(const int x) { return 1 << x; }
inline long long BLLD(const int x) { return 1LL << x; }
inline int BINT_TEST(const int s, const int x) { return (s & BINT(x)) != 0; }
inline int BLLD_TEST(const long long s, const int x) {
return (s & BLLD(x)) != 0LL;
}
template <class T>
inline T LOWBIT(const T x) {
return (x ^ (x - 1)) & x;
}
template <class T>
inline int BITCOUNT(const T x) {
return (!x) ? x : (1 + BITCOUNT(x & (x - 1)));
}
const double PI = acos(-1.0);
const double EPS = 1e-5;
template <class T>
inline T SQR(const T x) {
return x * x;
}
template <class T1, class T2>
inline T1 POW(const T1 x, const T2 y) {
if (!y)
return 1;
else if ((y & 1) == 0) {
return SQR(POW(x, y >> 1));
} else
return POW(x, y ^ 1) * x;
}
template <class T>
inline T GCD(const T x, const T y) {
if (x < 0) return GCD(-x, y);
if (y < 0) return GCD(x, -y);
return (!y) ? x : GCD(y, x % y);
}
template <class T>
inline T LCM(const T x, const T y) {
if (x < 0) return LCM(-x, y);
if (y < 0) return LCM(x, -y);
return x * (y / GCD(x, y));
}
template <class T>
inline T EEA(const T a, const T b, T &x, T &y) {
if (a < 0) {
T d = EEA(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EEA(a, -b, x, y);
y = -y;
return d;
}
if (!b) {
x = 1;
y = 0;
return a;
} else {
T d = EEA(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > FACTORIZE(T x) {
vector<pair<T, int> > ret;
if (x < 0) x = -x;
for (T i = 2; x > 1;) {
if (x % i == 0) {
int count = 0;
for (; x % i == 0; x /= i) count++;
ret.push_back(MP(i, count));
}
i++;
if (i > x / i) i = x;
}
return ret;
}
template <class T>
inline int ISPRIME(const T x) {
if (x <= 1) return 0;
for (T i = 2; SQR(i) <= x; i++)
if (x % i == 0) return 0;
return 1;
}
template <class T>
inline T EULARFUNCTION(T x) {
vector<pair<T, int> > f = FACTORIZE(x);
for (typename vector<pair<T, int> >::iterator it = f.begin(); it != f.end();
it++) {
x = x / it->first * (it->first - 1);
}
return x;
}
template <class T>
inline T INVERSEE(const T a, const T b) {
T x, y;
EEA(a, b, x, y);
return x ? x : 1;
}
template <class T>
inline T MOD_STD(const T x, const T m) {
return (x % m + m) % m;
}
template <class T>
inline T MOD_STD(const T x) {
return (x % MOD + MOD) % MOD;
}
template <class T>
inline T MOD_ADD(const T x, const T y, const T m) {
return (x + y) % m;
}
template <class T>
inline T MOD_ADD(const T x, const T y) {
return (x + y) % MOD;
}
template <class T>
inline void MOD_ADD(T *x, const T y, const T m) {
*x = (*x + y) % m;
}
template <class T>
inline void MOD_ADD(T *x, const T y) {
*x = (*x + y) % MOD;
}
template <class T>
inline T MOD_MUL(const T x, const T y, const T m) {
return (T)((1LL * x * y) % m);
}
template <class T>
inline T MOD_MUL(const T x, const T y) {
return (T)((1LL * x * y) % MOD);
}
template <class T>
inline void MOD_MUL(T *x, const T y, const T m) {
*x = (T)((1LL * (*x) * y) % m);
}
template <class T>
inline void MOD_MUL(T *x, const T y) {
*x = (T)((1LL * (*x) * y) % MOD);
}
template <class T1, class T2>
inline T1 MOD_POW(const T1 x, const T2 y, const T1 m) {
if (y == 0)
return 1 % m;
else if ((y & 1) == 0) {
T1 z = MOD_POW(x, y >> 1, m);
return MOD_MUL(z, z, m);
} else
return MOD_MUL(MOD_POW(x, y ^ 1, m), x, m);
}
template <class T1, class T2>
inline T1 MOD_POW(const T1 x, const T2 y) {
if (y == 0)
return 1 % MOD;
else if ((y & 1) == 0) {
T1 z = MOD_POW(x, y >> 1);
return MOD_MUL(z, z);
} else
return MOD_MUL(MOD_POW(x, y ^ 1), x);
}
template <class T>
class MATX {
private:
unsigned long hig, wid;
T *data;
void __init() {
this->data = (T *)malloc(sizeof(T) * this->hig * this->wid);
memset(this->data, 0, sizeof(T) * this->hig * this->wid);
}
public:
MATX() {
this->hig = this->wid = 1;
__init();
}
MATX(const unsigned long _len) {
this->hig = this->wid = _len;
__init();
}
MATX(const unsigned long _hig, const unsigned long _wid) {
this->hig = _hig;
this->wid = _wid;
__init();
}
MATX(const MATX &rhs) {
this->hig = rhs.hig;
this->wid = rhs.wid;
this->data = (T *)malloc(sizeof(T) * this->hig * this->wid);
for (unsigned long x = 0; x < this->hig; x++)
for (unsigned long y = 0; y < this->wid; y++)
this->data[x * this->wid + y] = rhs.at(x, y);
}
~MATX() { free(this->data); }
T &operator()(const unsigned long x, const unsigned long y) {
if (x >= this->hig || y >= this->wid) return (*(T *)NULL);
return this->data[x * wid + y];
}
MATX &operator=(const MATX &rhs) {
if (this->hig != rhs.hig || this->wid != rhs.wid) {
free(this->data);
this->hig = rhs.hig;
this->wid = rhs.wid;
this->data = (T *)malloc(sizeof(T) * this->hig * this->wid);
}
for (unsigned long x = 0; x < this->hig; x++)
for (unsigned long y = 0; y < this->wid; y++)
this->data[x * this->wid + y] = rhs.at(x, y);
return *this;
}
const MATX operator+(const MATX &opn) const {
MATX ret(*this);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
ret.data[x * ret.wid + y] += opn.at(x, y);
return ret;
}
const MATX operator-(const MATX &opn) const {
MATX ret(*this);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
ret.data[x * ret.wid + y] -= opn.at(x, y);
return ret;
}
const MATX operator*(const MATX &opn) const {
MATX ret(this->hig, opn.wid);
const unsigned long len = MIN(this->wid, opn.hig);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
for (unsigned long z = 0; z < len; z++)
ret.data[x * ret.wid + y] += this->at(x, z) * opn.at(z, y);
return ret;
}
const MATX mul(const MATX &opn) const { return *this * opn; }
template <class T2>
const MATX mul(const MATX &opn, const T2 m) const {
MATX ret(this->hig, opn.wid);
const unsigned long len = MIN(this->wid, opn.wid);
for (unsigned long x = 0; x < ret.hig; x++)
for (unsigned long y = 0; y < ret.wid; y++)
for (unsigned long z = 0; z < len; z++)
MOD_ADD(&ret.data[x * ret.wid + y],
MOD_MUL(this->at(x, z), opn.at(z, y), m), m);
return ret;
}
MATX &operator+=(const MATX &rhs) {
*this = *this + rhs;
return *this;
}
MATX &operator-=(const MATX &rhs) {
*this = *this - rhs;
return *this;
}
MATX &operator*=(const MATX &rhs) {
*this = *this * rhs;
return *this;
}
const MATX pow(const unsigned long p) const {
MATX buff(*this), ret(this->hig, this->wid);
ret.set_one();
if (p > 0)
for (unsigned long i = 1;; i <<= 1) {
if (p & i) ret *= buff;
buff *= buff;
if (i > (p >> 1)) break;
}
return ret;
}
template <class T2>
const MATX pow(const unsigned long p, const T2 m) const {
MATX buff(*this), ret(this->hig, this->wid);
ret.set_one();
if (p > 0)
for (unsigned long i = 1;; i <<= 1) {
if (p & i) ret = ret.mul(buff, m);
buff = buff.mul(buff, m);
if (i > (p >> 1)) break;
}
return ret;
}
const T at(const unsigned long x, const unsigned long y) const {
if (x >= this->hig || y >= this->wid) return 0;
return this->data[x * wid + y];
}
void show() const {
for (unsigned long x = 0; x < this->hig; x++) {
for (unsigned long y = 0; y < this->wid; y++)
cout << this->at(x, y) << " ";
cout << endl;
}
}
void set_one() {
for (unsigned long x = 0; x < this->hig; x++)
for (unsigned long y = 0; y < this->wid; y++)
this->data[x * this->wid + y] = (x == y) ? 1 : 0;
}
};
template <class T>
class Complex {
public:
T r, i;
Complex(T x = 0.0, T y = 0.0) {
this->r = x;
this->i = y;
}
Complex operator+(const Complex &opn) const {
return Complex(this->r + opn.r, this->i + opn.i);
}
Complex operator-(const Complex &opn) const {
return Complex(this->r - opn.r, this->i - opn.i);
}
Complex operator*(const Complex &opn) const {
return Complex(this->r * opn.r - this->i * opn.i,
this->r * opn.i + this->i * opn.r);
}
};
struct buff_s {
long long ful, pre, nxt, top;
buff_s() {}
buff_s(const long long f, const long long p, const long long n,
const long long t) {
this->ful = f;
this->pre = p;
this->nxt = n;
this->top = t;
}
};
int n, m, k, pos[160000];
long long a[160000], ans;
buff_s c[610000];
inline buff_s combine(const buff_s &lef, const buff_s &rig) {
buff_s buff;
buff.ful = lef.ful + rig.ful;
buff.pre = MAX(lef.pre, lef.ful + rig.pre);
buff.nxt = MAX(rig.nxt, lef.nxt + rig.ful);
buff.top = MAX(MAX(lef.top, rig.top), lef.nxt + rig.pre);
return buff;
}
void build(const int i, const int lef, const int rig) {
if (lef == rig) {
c[i].ful = a[lef];
c[i].pre = MAX(0LL, a[lef]);
c[i].nxt = MAX(0LL, a[lef]);
c[i].top = MAX(0LL, a[lef]);
} else {
int mid = (lef + rig) >> 1;
build((i << 1) + 1, lef, mid);
build((i << 1) + 2, mid + 1, rig);
c[i] = combine(c[(i << 1) + 1], c[(i << 1) + 2]);
}
}
buff_s query(const int i, const int lef, const int rig, const int src,
const int dst) {
if (dst < lef || src > rig) return buff_s(0LL, 0LL, 0LL, 0LL);
if (src <= lef && rig <= dst) {
return c[i];
} else {
int mid = (lef + rig) >> 1;
if (dst <= mid) return query((i << 1) + 1, lef, mid, src, dst);
if (src > mid) return query((i << 1) + 2, mid + 1, rig, src, dst);
return combine(query((i << 1) + 1, lef, mid, src, dst),
query((i << 1) + 2, mid + 1, rig, src, dst));
}
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n >> m >> k) {
for (int i = 0; i < n; i++) {
cin >> pos[i];
if (i) a[i] = (pos[i] - pos[i - 1]) * 50;
}
for (int i = 1; i < n; i++) {
int p;
cin >> p;
a[i] -= p * k;
}
build(0, 0, n - 1);
ans = 0LL;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
ans += query(0, 0, n - 1, u, v - 1).top;
}
cout << setiosflags(ios::fixed) << setprecision(8) << ans * 0.01 << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int co[100][100];
int dpl[100][100][100];
int dpr[100][100][100];
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
co[i][j] = 1e9 + 7;
}
}
for (int i = 0; i < m; i++) {
int b, e, c;
scanf("%d%d%d", &b, &e, &c);
b--, e--;
co[b][e] = min(co[b][e], c);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dpl[1][i][j] = i < j ? co[j][i] : 1e9 + 7;
dpr[1][i][j] = i < j ? co[i][j] : 1e9 + 7;
}
}
for (int t = 2; t <= k; t++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dpl[t][i][j] = 1e9 + 7;
dpr[t][i][j] = 1e9 + 7;
if (i < j) {
for (int p = 0; p < n; p++) {
dpl[t][i][j] = min(dpl[t][i][j], dpl[t - 1][j][p] + co[j][i]);
dpr[t][i][j] = min(dpr[t][i][j], dpr[t - 1][p][i] + co[i][j]);
}
}
}
}
}
for (int t = 2; t <= k - 1; t++) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int p = i + 1; p <= j - 1; p++) {
dpl[t][p][j] = min(dpl[t][p][j], dpr[t - 1][i][j] + co[j][p]);
dpr[t][i][p] = min(dpr[t][i][p], dpl[t - 1][i][j] + co[i][p]);
dpr[t][i][p] = min(dpr[t][i][p], dpr[t - 1][i][j] + co[j][p]);
dpl[t][p][j] = min(dpl[t][p][j], dpl[t - 1][i][j] + co[i][p]);
}
}
}
}
int ans = 1e9 + 7;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ans = min(ans, dpl[k - 1][i][j]);
ans = min(ans, dpr[k - 1][i][j]);
}
}
if (ans > 1e9) {
puts("-1");
} else {
printf("%d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int toMod = 1000000007;
int n, len, k;
int a[1 << 17];
long long fp[1 << 17];
long long fn[1 << 17];
inline long long abs64(long long x) {
if (x < 0) return -x;
return x;
}
inline void init() {
scanf("%d%d", &n, &len);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
fp[i] = 0;
fn[i] = 0;
if (a[i] > 0) fp[i] = a[i];
if (a[i] < 0) fn[i] = a[i];
if (i) {
fp[i] += fp[i - 1];
fn[i] += fn[i - 1];
}
}
scanf("%d", &k);
if (k > len) k = len;
}
inline long long getSumP(int l, int r) {
long long res = fp[r];
if (l) res -= fp[l - 1];
return res;
}
inline long long getSumN(int l, int r) {
long long res = fn[r];
if (l) res -= fn[l - 1];
return res;
}
struct megaset {
int cnt;
int LAST;
long long curSum;
int inSet[1 << 17];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
qmin;
priority_queue<pair<int, int> > qmax;
void clear() {
LAST = -1;
curSum = 0;
cnt = 0;
memset(inSet, 0, sizeof inSet);
while (!qmin.empty()) qmin.pop();
while (!qmax.empty()) qmax.pop();
}
void refresh() {
if (!k) return;
while (!qmax.empty()) {
if (qmax.top().second <= LAST) {
qmax.pop();
continue;
}
if (cnt == k) break;
pair<int, int> cur = qmax.top();
qmax.pop();
qmin.push(cur);
curSum += (long long)cur.first;
inSet[cur.second] = 1;
++cnt;
}
while (!qmax.empty()) {
if (qmax.top().second <= LAST) {
qmax.pop();
continue;
}
pair<int, int> cur = qmax.top();
while (!qmin.empty() && !inSet[qmin.top().second]) qmin.pop();
if (cur.first > qmin.top().first) {
qmax.pop();
pair<int, int> cur2 = qmin.top();
qmin.pop();
qmin.push(cur);
qmax.push(cur2);
curSum -= (long long)cur2.first;
curSum += (long long)cur.first;
inSet[cur2.second] = 0;
inSet[cur.second] = 1;
} else
break;
}
}
void remove(int id) {
LAST = id;
if (!inSet[id]) return;
inSet[id] = 0;
curSum -= a[id];
--cnt;
while (!qmin.empty() && !inSet[qmin.top().second]) qmin.pop();
refresh();
}
void add(int id) {
qmax.push(pair<int, int>(a[id], id));
refresh();
}
};
megaset A;
inline long long solve() {
A.clear();
for (int i = 0; i < len; ++i) {
if (a[i] > 0) A.add(i);
}
long long res =
abs64(getSumP(0, len - 1) - 2 * A.curSum + getSumN(0, len - 1));
for (int i = len; i < n; ++i) {
if (a[i - len] > 0) A.remove(i - len);
if (a[i] > 0) A.add(i);
long long cur =
abs64(getSumP(i - len + 1, i) - 2 * A.curSum + getSumN(i - len + 1, i));
res = max(res, cur);
}
return res;
}
int main() {
init();
long long res = solve();
for (int i = 0; i < n; ++i) a[i] = -a[i];
for (int i = 0; i < n; ++i) {
fp[i] = 0;
fn[i] = 0;
if (a[i] > 0) fp[i] = a[i];
if (a[i] < 0) fn[i] = a[i];
if (i) {
fp[i] += fp[i - 1];
fn[i] += fn[i - 1];
}
}
res = max(res, solve());
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, pair<int, int>> m;
vector<pair<string, int>> ip;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, maxscore = 0;
cin >> n;
for (int i = 0; i < n; i++) {
string name;
cin >> name;
int score;
cin >> score;
ip.push_back(make_pair(name, score));
if (m.find(name) == m.end())
m[name] = make_pair(score, i);
else {
pair<int, int> t = m[name];
t.first += score;
t.second = i;
m[name] = t;
}
}
for (auto it = m.begin(); it != m.end(); it++)
maxscore = max(maxscore, (it->second).first);
unordered_set<string> winners;
for (auto it = m.begin(); it != m.end(); it++)
if ((it->second).first == maxscore) winners.insert(it->first);
m.clear();
string winner;
bool found = false;
for (int i = 0; i < n; i++) {
string name = ip[i].first;
int score = ip[i].second;
if (m.find(name) == m.end()) {
m[name] = make_pair(score, i);
if (winners.count(name) && score >= maxscore) {
winner = name;
break;
}
} else {
pair<int, int> t = m[name];
t.first += score;
t.second = i;
m[name] = t;
if (winners.count(name) && t.first >= maxscore) {
winner = name;
break;
}
}
}
cout << winner;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
cout << (regex_match(s, regex("[0-9a-zA-Z_]{1,16}@[0-9a-zA-Z_]{1,16}(\\.[0-"
"9a-zA-Z_]{1,16})*(/[0-9a-zA-Z_]{1,16})?"))
? "YES"
: "NO")
<< endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[100010], c[100010];
long long mn = 1e9, mx = -1e9, ans, cnt, sm;
bool ok, okk, used[1000010], use[10];
bool ch(int x, int y, int j, int nn) {
for (int i = 0; i < nn; i++) {
if (abs(x * j) > abs(y)) {
return 0;
}
x *= j;
}
if (x == y) {
return true;
} else {
return false;
}
}
int main() {
int aa, bb, n;
cin >> aa >> bb >> n;
for (int i = -1000; i <= 1000; i++) {
if (ch(aa, bb, i, n)) {
cout << i;
return 0;
}
}
cout << "No solution";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100], dv[100];
long long calc(int n, int k, long long x) {
bool smaller = false;
for (int i = n - 1; i >= 0; i--) {
int modbit = n - 1 - (n - 1 - i) % k;
if (((x >> modbit) & 1) > ((x >> i) & 1)) {
smaller = true;
break;
} else if (((x >> modbit) & 1) < ((x >> i) & 1))
break;
}
long long num = x >> (n - k);
if (smaller) num--;
return num - (1LL << (k - 1)) + 1LL;
}
long long solve(long long num) {
long long ans = 0;
for (int i = 0; 1LL << i <= num; i++) {
int n = i + 1;
int cnt = 0;
for (int j = 1; j < n; j++)
if (n % j == 0) {
dv[cnt] = j;
dp[cnt] = calc(n, j, min((1LL << (i + 1)) - 1, num));
cnt++;
}
for (int j = 0; j <= cnt; j++)
for (int k = j + 1; k < cnt; k++)
if (dv[k] % dv[j] == 0) dp[k] -= dp[j];
for (int j = 0; j < cnt; j++) {
ans += dp[j];
}
}
return ans;
}
int main() {
long long l, r;
cin >> l >> r;
cout << solve(r) - solve(l - 1) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int T, n, nb, i, j, k;
int a[400005], b[400005];
int ans, upd;
int main() {
scanf("%d", &T);
while (T--) {
n = 0;
scanf("%d", &nb);
for (i = 1; i <= nb; i++) {
scanf("%d", &b[i]);
}
sort(b + 1, b + 1 + nb);
b[nb + 1] = 0;
for (i = 1; i <= nb; i++) {
if (b[i] != b[i + 1]) {
a[++n] = b[i];
}
}
ans = a[n];
for (i = n; i >= max(n - 300, 1); i--) {
for (j = i - 1; j >= max(n - 300, 1); j--) {
if (a[i] % a[j] == 0) continue;
ans = max(ans, a[i] + a[j]);
break;
}
}
for (i = n; i >= max(n - 300, 1); i--) {
for (j = i - 1; j >= max(n - 300, 1); j--) {
for (k = j - 1; k >= max(n - 300, 1); k--) {
if ((a[i] % a[j] == 0) || (a[i] % a[k] == 0) || (a[j] % a[k] == 0))
continue;
ans = max(ans, a[i] + a[j] + a[k]);
break;
}
}
}
printf("%d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, c = 0, d = 0, k = 0;
cin >> A >> B;
for (int i = 1; i <= 6; i++) {
if (abs(A - i) > abs(B - i))
c++;
else if (abs(A - i) < abs(B - i))
d++;
else
k++;
}
printf("%d %d %d", d, k, c);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
double m[N], b[N], k[N];
struct cht {
int ptr = 0, idx = 0;
bool bad(int l1, int l2, int l3) {
return 1.0 * (b[l3] - b[l1]) * (m[l1] - m[l2]) <=
1.0 * (b[l2] - b[l1]) * (m[l1] - m[l3]);
}
void add(double _m, double _b, int _k) {
m[idx] = _m, b[idx] = _b, k[idx] = _k;
idx++;
while (idx >= 3 && bad(idx - 3, idx - 2, idx - 1)) {
m[idx - 2] = m[idx - 1];
b[idx - 2] = b[idx - 1];
k[idx - 2] = k[idx - 1];
--idx;
}
}
double f(int i, double x) { return m[i] * x + b[i]; }
pair<double, int> query(double x) {
if (ptr >= idx) ptr = idx - 1;
while (ptr < idx - 1 && f(ptr, x) > f(ptr + 1, x)) ptr++;
return {f(ptr, x), k[ptr]};
}
void clear() { ptr = idx = 0; }
} ds;
double p[N], f[N], r[N];
pair<double, int> dp[N];
int n, K;
pair<double, int> get(double C) {
ds.clear();
ds.add(0, 0, 0);
for (int i = 1; i <= n; ++i) {
pair<double, int> tmp = ds.query(r[i]);
dp[i].first = tmp.first + f[i] + C;
dp[i].second = tmp.second + 1;
if (i < n) ds.add(-p[i], dp[i].first - f[i] + r[i] * p[i], dp[i].second);
}
return dp[n];
}
int main(int argc, char const *argv[]) {
scanf("%d %d", &n, &K);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
p[i] = p[i - 1] + x;
r[i] = r[i - 1] + 1.0 / (double)x;
f[i] = f[i - 1] + p[i] / x;
}
double lo = 0, hi = p[n] * 1e5 + 100;
int l = 0, r = n + 1;
double lval, rval;
while (fabs(hi - lo) > 1e-2) {
double mid = (lo + hi) / 2;
pair<double, int> tmp = get(mid);
if (tmp.second == K) {
double ans = tmp.first - K * mid;
printf("%.10f\n", ans);
return 0;
}
if (tmp.second < K)
hi = mid;
else
lo = mid;
}
double ans = get(hi).first - hi * K;
printf("%.10f\n", ans);
}
| 8 |
#include <bits/stdc++.h>
const int N = 1e7 + 10;
const unsigned long long base = 163;
const int INF = 0x3f3f3f3f;
using namespace std;
int a[N];
pair<int, int> b[N];
int c[N];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[a[i]]++;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i].first), b[i].second = i;
}
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
int tot = 0;
int o = 0;
for (int i = 1; i <= n; i++) {
if (a[i] >= tot) {
o++;
} else
return cout << -1, 0;
if (o == k) o = 0, tot++;
}
int ans = 0;
vector<int> q;
int r = 1;
for (int i = 0; i <= (int)1e7; i++) {
if (c[i] < k) {
while (b[r].first < i) r++;
while (r <= m && c[i] < k && b[r].first >= i) {
q.push_back(b[r].second);
r++;
c[i]++;
ans++;
}
}
}
cout << ans << endl;
for (auto i : q) cout << i << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 << 23;
bool a[maxn];
bool vis[maxn];
int n, m, x;
void dfs(int x) {
if (vis[x]) return;
vis[x] = true;
for (int i = 0; i <= n; i++)
if (x & (1 << i)) dfs(x ^ (1 << i));
if (a[x]) dfs((1 << n) - 1 - x);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) scanf("%d", &x), a[x] = true;
int ans = 0;
for (int i = 0; i < (1 << n); i++)
if (!vis[i] && a[i]) dfs(i), ans++;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, ad;
string s;
cin >> n;
int ls[n][n], ml[n];
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < n; j++) {
ls[i][j] = s[j] - 48;
}
}
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < n; j++) {
ad = s[j] - 48;
ls[i][j] = (ls[i][j] + ad) % 2;
}
}
cin >> s;
for (int i = 0; i < n; i++) {
ml[i] = s[i] - 48;
}
vector<int> beda[2 * n], sama[2 * n];
int par[2 * n];
bool cek = true;
for (int i = 0; i < 2 * n; i++) {
par[i] = -1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (ml[j] == 0) {
if (ml[i] == 0) {
if (ls[i][j] == 1) {
cek = false;
}
} else {
if (ls[i][j] == 0) {
if (par[n + j] == 1) {
cek = false;
} else {
par[n + j] = 0;
}
} else {
if (par[n + j] == 0) {
cek = false;
} else {
par[n + j] = 1;
}
}
}
} else {
if (ml[i] == 0) {
if (ls[i][j] == 0) {
if (par[i] == 1) {
cek = false;
} else {
par[i] = 0;
}
} else {
if (par[i] == 0) {
cek = false;
} else {
par[i] = 1;
}
}
} else {
if (ls[i][j] == 0) {
sama[i].push_back(n + j);
sama[n + j].push_back(i);
} else {
beda[i].push_back(n + j);
beda[n + j].push_back(i);
}
}
}
}
}
if (cek) {
int q[2 * n], p, r;
p = 0;
r = 0;
for (int i = 0; i < 2 * n; i++) {
if (par[i] != -1) {
q[r] = i;
r++;
}
}
while (p < 2 * n) {
if (p == r) {
ad = 0;
while (par[ad] != -1) {
ad++;
}
par[ad] = 0;
q[r] = ad;
r++;
} else {
for (int i = 0; i < sama[q[p]].size(); i++) {
if (par[sama[q[p]][i]] == -1) {
q[r] = sama[q[p]][i];
par[q[r]] = par[q[p]];
r++;
} else {
if (par[sama[q[p]][i]] != par[q[p]]) {
cek = false;
}
}
}
for (int i = 0; i < beda[q[p]].size(); i++) {
if (par[beda[q[p]][i]] == -1) {
q[r] = beda[q[p]][i];
par[q[r]] = (par[q[p]] + 1) % 2;
r++;
} else {
if (par[beda[q[p]][i]] == par[q[p]]) {
cek = false;
}
}
}
p++;
}
}
if (cek) {
int ans = 0;
for (int i = 0; i < 2 * n; i++) {
if (par[i] == 1) {
ans++;
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (par[i] == 1) {
cout << "row " << i << endl;
}
if (par[i + n] == 1) {
cout << "col " << i << endl;
}
}
} else {
cout << -1 << endl;
}
} else {
cout << -1 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > A;
vector<long long> PS;
long long b;
int N, K;
int position_in_sorting_massive[1000000];
int main() {
cin >> N >> K >> b;
A.resize(N);
PS.resize(N);
for (int i = 0; i < N; i++) {
cin >> A[i].first;
A[i].second = -i;
}
A.pop_back();
sort(A.rbegin(), A.rend());
for (int i = 0; i < N - 1; i++) {
PS[i] += A[i].first;
if (i) PS[i] += PS[i - 1];
}
for (int i = 0; i < N - 1; i++) {
position_in_sorting_massive[-A[i].second] = i;
}
for (int i = 0; i < N - 1; i++) {
long long sum = 0;
if (position_in_sorting_massive[i] < K)
sum = PS[K - 1];
else
sum = (K - 2 >= 0 ? PS[K - 2] : 0) +
A[position_in_sorting_massive[i]].first;
if (sum > b) {
cout << i + 1 << endl;
return 0;
}
}
cout << N << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
long long a[maxn];
const long long dig = 61;
long long sum[maxn];
long long cnt[maxn][2];
void solve() {
long long n;
cin >> n;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
a[i] = __builtin_popcountll(a[i]);
assert(a[i] < dig);
assert(a[i]);
sum[i] = (sum[i - 1] + a[i]) & 1;
}
for (long long i = 1; i <= n; i++) {
long long mx = 0, sm = 0;
for (long long j = i; j < i + dig && j <= n; j++) {
mx = max((long long)mx, a[j]);
sm += a[j];
if ((sm & 1) == 0 && mx * 2 <= sm) {
ans++;
}
}
}
cnt[0][0] = 1;
cnt[0][1] = 0;
for (long long i = 1; i <= n; i++) {
cnt[i][0] = cnt[i - 1][0];
cnt[i][1] = cnt[i - 1][1];
cnt[i][sum[i]]++;
}
for (long long i = dig + 1; i <= n; i++) ans += cnt[i - dig - 1][sum[i]];
cout << ans;
}
signed main() {
long long t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200010;
const int inf = 2147483647;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * f;
}
int n, a[Maxn], f[2][Maxn], ans = 0;
int main() {
memset(f, 63, sizeof(f));
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 2; i <= n; i++) {
int t;
t = upper_bound(f[1] + 1, f[1] + 1 + n, a[i] - i + 1) - f[1];
f[1][t] = a[i] - i + 1;
ans = max(ans, t);
t = upper_bound(f[0] + 1, f[0] + 1 + n, a[i - 1] - (i - 1)) - f[0];
f[0][t] = a[i - 1] - (i - 1);
f[1][t] = min(f[1][t], f[0][t]);
ans = max(ans, t);
}
printf("%d", max(n - ans - 1, 0));
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int vis[maxn * 2];
int num[maxn * 2];
int main() {
int n, x, v;
scanf("%d%d", &n, &x);
int t = 0, now = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &v);
v = v % x;
if (v >= maxn) continue;
int t = num[v];
if (t * x + v < maxn) {
vis[x * t + v] = 1;
num[v]++;
}
while (now < maxn && vis[now] == 1) {
now++;
}
cout << now << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
const long long maxn = 201110;
const long long M = 1e9 + 7;
long long n, m, k, ans;
unsigned long long p[maxn], all, a[15][15];
unsigned long long mo = 1e9 + 7;
vector<pair<long long, long long> > v[maxn];
void dfs(long long u, unsigned long long hash) {
if (u > k) {
ans += (hash == all);
return;
}
for (long long i = 1; i <= u; i++) {
dfs(u + 1, hash + a[u][i]);
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (long long i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
v[x].push_back({z, y});
}
p[0] = 1;
for (long long i = 1; i <= n; i++) {
p[i] = p[i - 1] * mo;
all += p[i];
}
for (long long i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end());
long long sz = v[i].size();
for (long long j = 0; j < sz; j++) {
a[sz][j + 1] += p[v[i][j].second];
}
}
dfs(1, 0);
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
char first[20];
char second[20];
int main() {
scanf("%s", first);
scanf("%s", second);
if (strcmp(first, "sunday") == 0) {
if (strcmp(second, "sunday") == 0 || strcmp(second, "tuesday") == 0 ||
strcmp(second, "wednesday") == 0)
printf("YES\n");
else
printf("NO\n");
}
if (strcmp(first, "monday") == 0) {
if (strcmp(second, "monday") == 0 || strcmp(second, "wednesday") == 0 ||
strcmp(second, "thursday") == 0)
printf("YES\n");
else
printf("NO\n");
}
if (strcmp(first, "tuesday") == 0) {
if (strcmp(second, "tuesday") == 0 || strcmp(second, "thursday") == 0 ||
strcmp(second, "friday") == 0)
printf("YES\n");
else
printf("NO\n");
}
if (strcmp(first, "wednesday") == 0) {
if (strcmp(second, "wednesday") == 0 || strcmp(second, "friday") == 0 ||
strcmp(second, "saturday") == 0)
printf("YES\n");
else
printf("NO\n");
}
if (strcmp(first, "thursday") == 0) {
if (strcmp(second, "thursday") == 0 || strcmp(second, "saturday") == 0 ||
strcmp(second, "sunday") == 0)
printf("YES\n");
else
printf("NO\n");
}
if (strcmp(first, "friday") == 0) {
if (strcmp(second, "friday") == 0 || strcmp(second, "sunday") == 0 ||
strcmp(second, "monday") == 0)
printf("YES\n");
else
printf("NO\n");
}
if (strcmp(first, "saturday") == 0) {
if (strcmp(second, "saturday") == 0 || strcmp(second, "monday") == 0 ||
strcmp(second, "tuesday") == 0)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
vector<char> s(n);
int acount = 0, gcount = 0, ccount = 0, tcount = 0, askcount = 0, maximal = 0;
for (int i = int(0); i < int(n); ++i) {
cin >> s[i];
if (s[i] == 'T') tcount++;
if (s[i] == 'A') acount++;
if (s[i] == 'G') gcount++;
if (s[i] == 'C') ccount++;
if (s[i] == '?') askcount++;
}
if (n % 4 != 0) {
cout << "===";
return 0;
}
maximal = max(max(max(tcount, acount), gcount), ccount);
int aneed = maximal - acount, gneed = maximal - gcount,
cneed = maximal - ccount, tneed = maximal - tcount;
if (aneed + gneed + cneed + tneed - askcount > 0) {
cout << "===";
return 0;
}
if ((aneed + gneed + cneed + tneed - askcount) % 4 != 0) {
cout << "===";
return 0;
}
for (int i = int(0); i < int(n); ++i) {
if (s[i] == '?') {
if (tcount < maximal) {
cout << 'T';
tcount++;
} else if (acount < maximal) {
cout << 'A';
acount++;
} else if (ccount < maximal) {
cout << 'C';
ccount++;
} else if (gcount < maximal) {
cout << 'G';
gcount++;
} else {
maximal++;
cout << 'T';
tcount++;
}
} else
cout << s[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, INF = 1e9;
int D[N][N], n, m, er, ec, sr, sc, k;
bool mark[N][N];
char t[N][N];
int dx[] = {0, -1, 1, 0};
int dy[] = {-1, 0, 0, 1};
queue<pair<int, int> > q;
void bfs(int r, int c) {
mark[r][c] = true;
D[r][c] = 0;
q.push({r, c});
while (q.size()) {
pair<int, int> v = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
pair<int, int> u = {v.first + dx[i], v.second + dy[i]};
if (!mark[u.first][u.second] && t[u.first][u.second] != 'T' &&
u.first <= n && u.first > 0 && u.second <= m && u.second > 0) {
mark[u.first][u.second] = true;
D[u.first][u.second] = D[v.first][v.second] + 1;
q.push(u);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> t[i][j];
if (t[i][j] == 'E') er = i, ec = j;
if (t[i][j] == 'S') sr = i, sc = j;
D[i][j] = INF;
}
bfs(er, ec);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (D[i][j] <= D[sr][sc] && isdigit(t[i][j])) k += t[i][j] - '0';
cout << k;
}
| 3 |
#include <bits/stdc++.h>
bool Contains(std::string s, char a) {
for (int i = 0; i < s.size(); ++i) {
if (s[i] == a) return true;
}
return false;
}
void MakeStrings(std::string it, std::string& s1, std::string& s2, char a) {
bool ch = true;
for (int i = 0; i < it.size(); ++i) {
if (it[i] == a) {
ch = false;
continue;
}
if (ch)
s1.push_back(it[i]);
else
s2.push_back(it[i]);
}
}
void Merge(std::list<std::string>::iterator& it, std::string& s, char a,
std::list<std::string>& another_list) {
std::string s1, s2, s3, s4;
if (s.empty()) {
s = *it;
return;
}
if (!Contains(s, a))
another_list.push_back(*it);
else {
MakeStrings(*it, s1, s2, a);
MakeStrings(s, s3, s4, a);
s1 = s1.size() >= s3.size() ? s1 : s3;
s2 = s2.size() >= s4.size() ? s2 : s4;
s = s1 + a + s2;
}
}
int main() {
int n;
std::cin >> n;
std::list<std::string> strings_list;
for (int i = 0; i < n; ++i) {
std::string s;
std::cin >> s;
strings_list.push_back(s);
}
std::list<std::string> another_list;
std::list<std::string> one_more;
std::string s;
do {
one_more = another_list;
for (int i = 97; i < 123; ++i) {
another_list.clear();
for (std::list<std::string>::iterator it = strings_list.begin();
it != strings_list.end(); ++it) {
if (Contains(*it, char(i)))
Merge(it, s, char(i), another_list);
else
another_list.push_back(*it);
}
strings_list = another_list;
}
if (one_more == another_list) {
std::cout << s;
s.clear();
}
} while (!another_list.empty());
std::cout << s << std::endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p = 0, q = 0, max1 = INT_MIN, k, m, s = 0;
cin >> n;
while (n--) {
s = 0;
cin >> m >> k;
s = s + q - m;
s = s + k;
max1 = max(max1, s);
q = s;
}
cout << max1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
struct Input {
int n;
vector<int64_t> a;
bool read() {
if (scanf("%d", &n) != 1) return 0;
a.resize(n);
for (int i = int(0); i < int(n); ++i) {
scanf("%" SCNd64, &a[i]);
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
vector<int> ans;
void write() {
if (ans.empty()) {
printf("-1\n");
} else {
for (int x : ans) {
printf("%d ", x);
}
printf("\n");
}
}
};
const int B_SIZE = 42;
struct Solution : Data {
vector<int> ncnt, bcnt;
bool can(int m) {
vector<int> good, rest;
good.assign(B_SIZE, 0);
rest = good;
vector<int> t_ncnt = ncnt;
if (t_ncnt[0] < m) {
return false;
}
int mval = m;
for (int i = 0; i < B_SIZE; ++i) {
int nval = min(mval, t_ncnt[i]);
int diff = mval - nval;
t_ncnt[i] -= nval;
good[i] = diff;
mval = nval;
}
for (int i = 0; i < B_SIZE; ++i) {
rest[i] = t_ncnt[i] + bcnt[i];
}
int accum = 0;
for (int i = 40; i >= 0; --i) {
if (accum + good[i] < rest[i]) {
return false;
}
accum += good[i] - rest[i];
}
return true;
}
void solve() {
ans.clear();
ncnt.assign(B_SIZE, 0);
bcnt = ncnt;
for (int64_t x : a) {
int pos = 0;
while (x > (1ll << pos)) pos++;
if (x == (1ll << pos)) {
ncnt[pos]++;
} else {
bcnt[pos]++;
}
}
int lm = (ncnt[0] + 1) / 2, rm = ncnt[0];
for (int tm = lm; tm <= rm; ++tm) {
if (can(tm)) ans.push_back(tm);
}
}
void clear() { *this = Solution(); }
};
Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin(
"input"
".in");
ofstream fout(
"input"
".out");
const int MAX_N = 300050;
const int INF = int(2e9);
struct Segment {
int l, r, pos;
};
bool comp(Segment a, Segment b) {
if (a.l != b.l) {
return a.l < b.l;
}
return a.r > b.r;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<Segment> segments(n);
vector<Segment> rMins(n);
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
segments[i].l = l;
segments[i].r = r;
segments[i].pos = i + 1;
}
sort(segments.begin(), segments.end(), comp);
Segment currMin;
currMin.r = INF;
for (int i = n - 1; i >= 0; i--) {
if (segments[i].r < currMin.r) {
rMins[i] = segments[i];
} else {
rMins[i] = currMin;
}
}
for (int i = 0; i < n - 1; i++) {
if (rMins[i + 1].r <= segments[i].r) {
cout << rMins[i + 1].pos << " " << segments[i].pos;
return 0;
}
}
cout << -1 << " " << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400000 + 5;
int f[N], rest[N];
int n, x, y, mex;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> x;
for (int i = 1; i <= n; ++i) {
cin >> y;
++rest[y % x];
while (true) {
if (mex > N) break;
if (rest[mex % x] > 0)
--rest[mex % x], ++mex;
else
break;
}
cout << mex << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> pref;
void realadd(int l, int r, int value) {
pref[l] += value;
pref[r + 1] -= value;
}
int main() {
int n, m;
cin >> n >> m;
pref.resize(n + 2);
vector<int> rex(m);
for (int &t : rex) {
cin >> t;
}
for (int i = 1; i < m; i++) {
int a = rex[i - 1];
int b = rex[i];
if (a > b) {
swap(a, b);
}
if (a == b) {
continue;
}
realadd(1, a - 1, b - a);
realadd(b + 1, n, b - a);
realadd(a + 1, b - 1, b - a - 1);
realadd(a, a, b - 1);
realadd(b, b, a);
}
long long current = 0;
vector<long long> result;
for (int i = 1; i <= n; i++) {
current += pref[i];
result.push_back(current);
}
for (long long t : result) {
cout << t << ' ';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long x[200005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
map<long long, long long> m;
long long mx = 0;
for (long long i = 0; i < n; i++) {
cin >> x[i];
m[x[i]] = i + 1;
mx = max(mx, x[i]);
}
sort(x, x + n);
long long alt1 = 0, alt2 = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 32; j++) {
long long a = (1LL << j);
bool b = (m.find(x[i] + a) != m.end());
bool c = (m.find(x[i] + a + a) != m.end());
if (b) {
alt1 = x[i];
alt2 = x[i] + a;
}
if (c) {
alt1 = x[i];
alt2 = x[i] + a + a;
}
if (x[i] + a + a > mx) break;
if (b and c) {
cout << 3 << endl;
cout << x[i] << " " << x[i] + a << " " << x[i] + a + a;
return 0;
}
}
}
if (alt2 != alt1) {
cout << 2 << endl;
cout << alt1 << " " << alt2;
} else {
cout << 1 << endl;
cout << x[0];
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
int a[maxn], b[maxn];
int flag[maxn], cnt[maxn];
int mark[maxn];
int Q[maxn * 4];
int ans;
bool check(int cut) {
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= n; i++) {
mark[a[i]] = 1;
}
for (int i = 1; i <= cut; i++) {
mark[b[i]] = 1;
}
int cur = 1, L = cut + 1;
while (cur <= n) {
if (!mark[cur]) {
return 0;
}
mark[b[L]] = 1;
L++, cur++;
}
return 1;
}
void solve() {
int l = 0, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid + n;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << endl;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
flag[a[i]]++;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
int idx = 0;
for (int i = n; i >= 1; i--) {
if (b[i] == 1) {
idx = i;
break;
}
}
if (idx) {
bool flag = 0;
for (int j = idx; j <= n; j++) {
if (b[j] != j - idx + 1) {
flag = 1;
break;
}
}
if (flag) {
solve();
} else {
for (int i = 1; i <= n; i++) {
mark[a[i]] = 1;
}
for (int i = idx; i <= n; i++) {
mark[b[i]] = 1;
}
int cur = b[n] + 1, L = 1;
int step = 0;
while (cur <= n) {
if (!mark[cur]) {
flag = 1;
break;
}
mark[b[L]] = 1;
L++, cur++, step++;
}
if (flag) {
solve();
} else {
cout << step << endl;
}
}
} else {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
auto rnd = bind(uniform_int_distribution<int>(1, 10000), mt19937(time(0)));
bool is_prime(int n, int p) {
for (int i = 2; i <= sqrt(n) && i <= p; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1)
return binpow(a, n - 1) * a;
else {
long long b = binpow(a, n / 2);
return b * b;
}
}
void solve() {
int n;
cin >> n;
int m;
cin >> m;
vector<vector<int>> a(n, vector<int>(m));
map<int, int> mp;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
mp[a[i][j]] = i;
}
}
vector<vector<int>> ans;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int x;
cin >> x;
if (i == 0) {
ans.push_back(a[mp[x]]);
}
}
}
for (auto i : ans) {
for (auto j : i) {
cout << j << " ";
}
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie();
cout.tie();
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[6][6], c = 0, i, j, d;
for (i = 1; i < 6; i++) {
for (j = 1; j < 6; j++) cin >> a[i][j];
}
for (i = 1; i < 6; i++) {
for (j = 1; j < 6; j++) {
if (a[i][j] == 1) {
if (i == 1 || i == 5)
c = 2;
else if (i == 2 || i == 4)
c = 1;
else
c = 0;
}
if (a[i][j] == 1) {
if (j == 1 || j == 5)
d = 2;
else if (j == 2 || j == 4)
d = 1;
else
d = 0;
cout << (c + d);
break;
}
}
}
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 1000005;
const int mod = 998244353;
int res, ans, n;
int fac[maxn], inv[maxn];
void update(int &x, int y) {
x += y;
if (x < 0) {
x += mod;
}
if (x >= mod) {
x -= mod;
}
}
int mpow(int x, int y) {
update(x, 0);
int z = 1;
for (; y; y >>= 1) {
if (y & 1) {
z = 1ll * z * x % mod;
}
x = 1ll * x * x % mod;
}
return z;
}
int calc(int x, int y) {
return 1ll * fac[x] * inv[y] % mod * inv[x - y] % mod;
}
int main() {
scanf("%d", &n);
fac[0] = 1, inv[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = 1ll * fac[i - 1] * i % mod;
inv[i] = mpow(fac[i], mod - 2);
}
for (int i = 1; i <= n; i++) {
int a = 1ll * calc(n, i) * mpow(-1, i + 1) % mod;
int x = mpow(3, (1ll * n * (n - i) + i) % (mod - 1));
update(ans, 1ll * a * x % mod);
}
ans = 2 * ans % mod;
for (int i = 0; i < n; i++) {
int t = mod - mpow(3, i);
int x = (mpow(t + 1, n) + mod - mpow(t, n)) % mod;
int a = 1ll * calc(n, i) * mpow(-1, i + 1) % mod;
update(res, 1ll * a * x % mod);
}
res = 3ll * res % mod;
printf("%d\n", (ans + res) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int oo = 1073741819;
using namespace std;
int f[2000000], g[21][1048577], n, len, a[2000000], s[2000000], c[2000000], ans;
char ch[300000][21];
int check(int x, int y) {
int ne, na, j, k = len;
for (ne = x & 1, na = (y >> (len - 1)) & 1, x >>= 1, j = 1; j <= len;
ne = ne | ((x & 1) << j), na = (na << 1) + ((y >> (len - j - 1)) & 1),
j++, x >>= 1)
if (ne == na) k = min(k, len - j);
return k;
}
void init() {
int sum, cos, i, ne, j, little;
scanf("%d\n", &n);
for (i = 1; i <= n; i++) scanf("%s\n", ch[i] + 1);
len = strlen(ch[1] + 1);
for (i = 1; i <= n; i++) {
ne = 0;
for (j = 1; j <= len; j++) ne = (ne << 1) + (ch[i][j] - '0');
c[i] = ne;
}
c[0] = 0;
for (i = 1; i <= n; i++) a[i] = check(c[i - 1], c[i]);
a[1] = len;
for (i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
memset(g, 61, sizeof(g));
little = len;
for (i = 1; i <= n - 1; i++) {
sum = little;
for (ne = c[i + 1], j = len; j; j--, ne >>= 1) {
cos = g[j][ne] + (len - j);
if (cos < sum) sum = cos;
}
f[i] = sum + s[i];
for (cos = c[i] >> 1, ne = c[i] & 1, j = 1; j <= len;
j++, ne = ne | ((cos & 1) << (j - 1)), cos >>= 1)
if (f[i] - s[i + 1] < g[j][ne]) g[j][ne] = f[i] - s[i + 1];
if (f[i] - s[i + 1] + len < little) little = f[i] - s[i + 1] + len;
}
ans = s[n];
for (i = 1; i <= n - 1; i++) ans = min(ans, f[i] + s[n] - s[i + 1]);
printf("%d\n", ans);
}
int main() {
init();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 2505;
char a[NMAX][NMAX];
int dp[NMAX][NMAX];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", a[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1];
if (a[i - 1][j - 1] == '1') dp[i][j] += 1;
}
int mins = n * m;
for (int k = 2; k <= max(n, m); ++k) {
int cnt = 0;
for (int i = 0; i < n; i += k)
for (int j = 0; j < m; j += k) {
int nr1 = dp[min(i + k, n)][min(j + k, m)] + dp[i][j];
nr1 -= dp[min(i + k, n)][j] + dp[i][min(j + k, m)];
nr1 = min(nr1, k * k - nr1);
cnt += nr1;
}
mins = min(mins, cnt);
}
printf("%d\n", mins);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> ans(n);
stack<int> sk;
vector<pair<int, int>> opt;
bool pos = true;
for (int x = 0, jp = 0; x < 2 * n && pos; x++) {
char c;
cin >> c;
if (c == '+') {
opt.push_back({1, jp});
sk.push(jp++);
} else {
int i;
cin >> i;
if (sk.empty())
pos = false;
else {
ans[sk.top()] = i;
sk.pop();
}
opt.push_back({-1, i});
}
}
priority_queue<int, vector<int>, greater<int>> pq;
for (auto [m, i] : opt) {
if (m == 1)
pq.push(ans[i]);
else {
if (pq.empty() || pq.top() != i) {
pos = false;
break;
}
pq.pop();
}
}
if (!pos)
cout << "NO\n";
else {
cout << "YES\n";
for (auto &i : ans) cout << i << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
pair<long long, long long> pts[500000 + 10];
long long prod(long long p1, long long p2) {
long long ret =
pts[p1].first * pts[p2].second - pts[p1].second * pts[p2].first;
return ret;
}
int main() {
long long n;
scanf("%lld", &n);
for (int i = 0, _n = n; i < _n; i++)
scanf("%lld%lld", &pts[i].first, &pts[i].second);
reverse(pts, pts + n);
long long total = 0LL;
for (int i = 1, _n = n; i < _n; i++) total += prod(i - 1, i);
total += prod(n - 1, 0);
long long small = 0LL;
long long curr = 0LL;
long long sum1 = 0LL;
long long sum2 = 0LL;
long long b = 0;
pts[n] = make_pair(0, 0);
for (long long a = 0; a < n; a++) {
while (1) {
if (((unsigned long long)(curr) +
(unsigned long long)(prod(b, (b + 1) % n)) +
(unsigned long long)(prod((b + 1) % n, a))) *
2ULL >
(unsigned long long)(total))
break;
if (((unsigned long long)(curr) +
(unsigned long long)(prod(b, (b + 1) % n)) +
(unsigned long long)(prod((b + 1) % n, a))) *
2ULL ==
(unsigned long long)(total) &&
b < a)
break;
if (b == n - 1) {
curr += prod(n - 1, 0);
b = 0;
sum1 = (sum1 + n * (prod(n - 1, 0) % MOD)) % MOD;
if (sum1 < 0) sum1 += MOD;
} else {
curr += prod(b, b + 1);
if (b >= a)
sum1 = (sum1 + (b + 1) * (prod(b, b + 1) % MOD)) % MOD;
else
sum1 = (sum1 + (b + n + 1) * (prod(b, b + 1) % MOD)) % MOD;
b++;
}
pts[n].first = (pts[n].first + pts[b].first) % MOD;
pts[n].second = (pts[n].second + pts[b].second) % MOD;
}
sum2 = ((curr % MOD) * (b + 1 + (b < a ? n : 0)) - sum1) % MOD;
sum2 = (sum2 + (prod(n, a) % MOD)) % MOD;
if (((unsigned long long)(curr) + (unsigned long long)(prod(b, a))) *
2ULL ==
(unsigned long long)(total) &&
b < a)
sum2 = (sum2 - curr % MOD - prod(b, a) % MOD + MOD) % MOD;
small = (small + sum2) % MOD;
if (small < 0) small += MOD;
if (a == n - 1) continue;
pts[n].first = (pts[n].first - pts[a + 1].first + MOD) % MOD;
pts[n].second = (pts[n].second - pts[a + 1].second + MOD) % MOD;
curr -= prod(a, a + 1);
sum1 = (sum1 - (a + 1) * (prod(a, a + 1) % MOD)) % MOD;
sum1 = ((sum1 % MOD) + MOD) % MOD;
}
printf("%lld\n",
((((total % MOD) * ((n * (n - 3) / 2) % MOD) - 2LL * small) % MOD) +
MOD) %
MOD);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
int n, m;
std::vector<std::vector<std::pair<int, int>>> g;
std::vector<long long> dist;
std::vector<std::vector<long long>> dest;
std::vector<std::vector<std::pair<long long, long long>>> swt;
void dfs1(int v) {
for (auto& ch : (g[v])) {
dist[ch.first] = dist[v] + ch.second;
dfs1(ch.first);
}
}
std::pair<std::set<long long>, long long> dfs2(int v) {
std::vector<std::set<long long>> sets;
std::vector<long long> wei;
int last = -1;
std::pair<int, int> big = std::make_pair(-1, -1);
for (auto& ch : (g[v])) {
auto pr = dfs2(ch.first);
if (((int)(pr.first).size()) > 0) {
sets.push_back(std::move(pr.first));
wei.push_back(-ch.second + pr.second);
big = std::max(big, std::make_pair(((int)(sets.back()).size()),
((int)(sets).size()) - 1));
last = ((int)(sets).size()) - 1;
} else
last = -1;
}
long long off = 0;
if (big.second != -1) {
std::swap(sets[0], sets[big.second]);
std::swap(wei[0], wei[big.second]);
if (last == big.second) last = 0;
off = wei[0];
std::set<long long> other;
for (int i = (1); i < (((int)(sets).size())); ++i)
for (auto& j : (sets[i]))
other.insert(j + wei[i] - off), sets[0].insert(j + wei[i] - off);
for (int i = (1); i < (((int)(sets).size())); ++i)
for (auto& j : (sets[i])) {
long long val = j + wei[i] - off;
auto it = sets[0].lower_bound(val);
if (it != sets[0].begin() &&
sets[i].count(*std::prev(it) - wei[i] + off) == 0)
swt[v].push_back(std::make_pair(*std::prev(it) + off + 1, *it + off));
if (std::next(it) != sets[0].end() && other.count(*std::next(it)) == 0)
swt[v].push_back(std::make_pair(*it + off + 1, *std::next(it) + off));
}
long long sma = *sets[0].begin();
if (last == -1)
swt[v].push_back(std::make_pair(1ll, sma + off));
else if (last == 0) {
if (other.count(sma) != 0)
swt[v].push_back(std::make_pair(1ll, sma + off));
} else {
if (sets[last].count(sma - wei[last] + off) == 0)
swt[v].push_back(std::make_pair(1ll, sma + off));
}
std::sort(swt[v].begin(), swt[v].end());
} else {
assert(((int)(sets).size()) == 0);
sets.emplace_back();
}
for (auto& i : (dest[v])) sets[0].insert(i - off);
return std::make_pair(std::move(sets[0]), off);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> m;
if (n == 1) {
std::cout << "-1 0\n";
return 0;
}
g.resize(n);
dist.resize(n);
dest.resize(n);
swt.resize(n);
for (int i = 0; i < (n - 1); ++i) {
int a, b, c;
std::cin >> a >> b >> c;
a--;
b--;
g[a].push_back(std::make_pair(b, c));
}
dfs1(0);
for (int i = 0; i < (m); ++i) {
int s, t;
std::cin >> s >> t;
s--;
dest[s].push_back(t + dist[s]);
}
dfs2(0);
std::vector<std::pair<long long, long long>> prze;
for (int i = 0; i < (n); ++i) {
for (auto& j : (swt[i])) prze.push_back(j);
}
std::sort(prze.begin(), prze.end());
std::priority_queue<long long, std::vector<long long>,
std::greater<long long>>
up;
long long ans = -1;
auto it = prze.begin();
long long time = it->first;
while (it != prze.end() && it->first <= time) {
assert(it->first == time);
up.push(it->second);
it++;
}
while (((int)(up).size())) {
long long cur = up.top();
up.pop();
if (cur < time) {
assert(cur == time - 1);
ans = cur;
break;
}
time++;
while (it != prze.end() && it->first <= time) {
assert(it->first == time);
up.push(it->second);
it++;
}
if (((int)(up).size()) == 0 && it != prze.end()) {
time = it->first;
while (it != prze.end() && it->first <= time) {
assert(it->first == time);
up.push(it->second);
it++;
}
}
}
if (ans == -1) {
std::cout << ans << " " << ((int)(prze).size()) << "\n";
} else {
std::cout << ans << " ";
int cnt = 0;
for (auto& i : (prze))
if (i.second < ans) cnt++;
std::cout << cnt << "\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 222222;
int n, m, k, rnk[MAXN];
vector<int> fwd[MAXN], bwd[MAXN];
int T, vis[MAXN], ret[MAXN];
int tp, topo[MAXN];
int lo[MAXN], hi[MAXN];
int idx[MAXN];
int ans[MAXN];
priority_queue<pair<int, int> > que;
inline int min(int a, int b) { return a < b ? a : b; }
inline int max(int a, int b) { return a < b ? b : a; }
inline void addEdge(int u, int v) {
fwd[u].push_back(v);
bwd[v].push_back(u);
}
inline void invalid() {
printf("-1\n");
exit(0);
}
void dfs(int u) {
vis[u] = ++T;
for (auto v : fwd[u]) {
if (!vis[v]) {
dfs(v);
} else {
if (!ret[v]) invalid();
}
}
ret[u] = T;
topo[++tp] = u;
}
inline void reverse(int a[], int u, int v) {
for (int i = u, j = v; i < j; ++i, --j) {
a[i] ^= a[j], a[j] ^= a[i], a[i] ^= a[j];
}
}
int cmp(int u, int v) { return hi[u] > hi[v]; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) scanf("%d", rnk + i);
for (int i = 1, u, v; i <= m; ++i) {
scanf("%d%d", &u, &v);
addEdge(u, v);
}
memset(vis, 0, sizeof(vis));
memset(ret, 0, sizeof(ret));
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
dfs(i);
}
reverse(topo, 1, n);
for (int i = 1; i <= n; ++i) {
if (rnk[i]) {
lo[i] = hi[i] = rnk[i];
} else {
lo[i] = 1, hi[i] = k;
}
}
for (int i = 1; i <= n; ++i) {
int v = topo[i];
for (auto u : bwd[v]) {
hi[v] = min(hi[v], hi[u] - 1);
}
if (lo[v] > hi[v]) invalid();
}
for (int i = n; i; --i) {
int u = topo[i];
for (auto v : fwd[u]) {
lo[u] = max(lo[u], lo[v] + 1);
}
if (lo[u] > hi[u]) invalid();
}
for (int i = 1; i <= n; ++i) idx[i] = i;
sort(idx + 1, idx + n + 1, cmp);
for (int i = k, j = 1; i; --i) {
for (; j && hi[idx[j]] >= i; ++j) {
que.push(pair<int, int>(lo[idx[j]], idx[j]));
}
for (; !que.empty() && que.top().first > i; que.pop())
;
if (que.empty()) invalid();
int u = que.top().second;
que.pop();
ans[u] = i;
lo[u] = hi[u] = i;
}
for (int i = 1; i <= n; ++i) {
int v = topo[i];
for (auto u : bwd[v]) {
hi[v] = min(hi[v], hi[u] - 1);
}
}
for (int i = 1; i <= n; ++i) {
if (!ans[i]) {
ans[i] = hi[i];
}
}
for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
printf("\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4010, Mo = 998244353, K = 256;
int ans, k;
int C[K][K], rev[K], wn[K], inv[K + 1], F[K];
inline int gi() {
int x = 0, o = 1;
char ch = getchar();
while (ch < '0' || ch > '9') ch == '-' ? o = -1 : 0, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return o * x;
}
inline int Pow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1LL * ret * x % Mo;
x = 1LL * x * x % Mo, y >>= 1;
}
return ret;
}
inline void NTT(int *a, int n, int f) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += i << 1)
for (int k = 0, w = 1; k < i; k++, w = 1LL * w * wn[i] % Mo) {
int x = a[j + k], y = 1LL * a[j + k + i] * w % Mo;
a[j + k] = (x + y) % Mo, a[j + k + i] = (x - y) % Mo;
}
if (f == 1) return;
reverse(a + 1, a + n);
for (int i = 0; i < n; i++) a[i] = 1LL * a[i] * inv[n] % Mo;
}
inline void get_inv(int n, int L, int *a, int *b) {
if (n == 2) {
b[0] = Pow(a[0], Mo - 2), b[1] = 0;
return;
}
get_inv(n >> 1, L - 1, a, b);
for (int i = 0; i < n; i++) rev[i] = ((rev[i >> 1] >> 1) | (i & 1) << L - 1);
memset(F, 0, n << 2);
for (int i = 0; i < n >> 1; i++) F[i] = a[i];
NTT(F, n, 1), NTT(b, n, 1);
for (int i = 0; i < n; i++) b[i] = (2 - 1LL * F[i] * b[i]) % Mo * b[i] % Mo;
NTT(b, n, -1);
for (int i = n >> 1; i < n; i++) b[i] = 0;
}
struct Dat {
int n, tt;
int head[N], to[N * 2], nxt[N * 2], f[N][K], c[N][K], g[N][K], q[N][K];
inline void dfs(int x, int fa) {
++c[x][0];
for (int i = head[x]; i; i = nxt[i])
if (to[i] != fa) dfs(to[i], x);
for (int i = head[x]; i; i = nxt[i])
for (int j = 2; j <= k; j++) c[x][j] = (c[x][j] - f[to[i]][j - 2]) % Mo;
get_inv(K, 8, c[x], f[x]);
}
inline void solve(int x, int fa) {
get_inv(K, 8, c[x], g[x]);
memcpy(q[x], c[x], sizeof(c[x]));
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y != fa) {
for (int j = 2; j <= k; j++) c[x][j] = (c[x][j] + f[y][j - 2]) % Mo;
memset(f[x], 0, sizeof(f[x]));
get_inv(K, 8, c[x], f[x]);
for (int j = 2; j <= k; j++) c[y][j] = (c[y][j] - f[x][j - 2]) % Mo;
solve(y, x);
memcpy(c[x], q[x], sizeof(c[x]));
}
}
}
inline void init() {
for (int i = 1; i < n; i++) {
int x = gi(), y = gi();
to[++tt] = y, nxt[tt] = head[x], head[x] = tt;
to[++tt] = x, nxt[tt] = head[y], head[y] = tt;
}
dfs(1, 0), solve(1, 0);
}
} A, B;
int main() {
cin >> A.n >> B.n >> k;
for (int i = 1; i < K; i <<= 1)
wn[i] = Pow(3, (Mo - 1) / (i << 1)), inv[i + i] = Pow(i + i, Mo - 2);
if (k & 1) return cout << 0, 0;
A.init(), B.init();
for (int i = 0; i <= k; i++)
for (int j = C[i][0] = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % Mo;
for (int i = 0; i <= k; i += 2) {
int s = 0;
for (int j = 1; j <= A.n; j++) s = (s + A.g[j][i]) % Mo;
s = 1LL * s * C[k][i] % Mo;
for (int j = 1; j <= B.n; j++) ans = (ans + 1LL * s * B.g[j][k - i]) % Mo;
}
cout << (ans + Mo) % Mo;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using vi = vector<int>;
char s[5000];
int main() {
scanf("%s", s);
int n = strlen(s);
vector<char> a;
a.clear();
int l = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u') {
a.clear();
l = 0;
} else {
l++;
bool flag = false;
for (auto c : a) flag |= (s[i] == c);
if (!flag) a.push_back(s[i]);
if (l >= 3 && (int)a.size() >= 2) {
printf(" ");
a.clear();
a.push_back(s[i]);
l = 1;
}
}
printf("%c", s[i]);
}
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int k = 0; k < t; k++) {
int a, b, p;
string s;
cin >> a >> b >> p >> s;
int price = 0;
for (int i = 1; i <= s.size(); i++) {
if (i == 1 || s[s.size() - 1 - i] != s[s.size() - i]) {
if (s[s.size() - 1 - i] == 'A') {
price += a;
} else {
price += b;
}
if (price > p) {
cout << s.size() - i + 1 << endl;
break;
}
}
if (i == s.size()) cout << 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long t;
long long m = 1e9 + 7;
long long arr[200005], cnt[200005];
multiset<long long> st[200005], s;
vector<long long> v[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long a, b, c, d, e, f, g, i, j;
cin >> a >> b;
for (i = 0; i < a; i++) {
cin >> arr[i];
}
sort(arr, arr + a);
for (i = 1; i <= b; i++) {
cin >> cnt[i];
}
g = 0;
long long chk = 0;
s.insert(200005);
for (i = a - 1; i >= 0; i--) {
d = arr[i];
f = cnt[d];
f--;
auto it = s.lower_bound(f);
auto n = s.begin();
if (f < *n) {
g++;
s.insert(1);
st[1].insert(g);
v[g].push_back(arr[i]);
} else {
if (f < *it) it--;
e = *it;
s.erase(it);
s.insert(e + 1);
auto tt = st[e].begin();
j = *tt;
st[e].erase(tt);
st[e + 1].insert(j);
v[j].push_back(arr[i]);
}
}
cout << g << endl;
for (i = 1; i <= g; i++) {
cout << v[i].size();
for (j = 0; j < v[i].size(); j++) {
cout << ' ' << v[i][j];
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100010, inf = 1e9 + 233;
long long n, m, N;
long long f[1 << 20], g[1 << 20];
char s[21][maxn];
template <typename T>
inline void read(T &k) {
long long f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
inline void FWT(long long *a) {
for (long long i = 2; i <= N; i <<= 1) {
for (long long j = 0, m = i >> 1; j < N; j += i) {
for (long long k = 0; k < m; k++) {
long long x = a[j + k], y = a[j + k + m];
a[j + k] = x + y;
a[j + k + m] = x - y;
}
}
}
}
inline void IFWT(long long *a) {
for (long long i = 2; i <= N; i <<= 1) {
for (long long j = 0, m = i >> 1; j < N; j += i) {
for (long long k = 0; k < m; k++) {
long long x = a[j + k], y = a[j + k + m];
a[j + k] = (x + y) >> 1;
a[j + k + m] = (x - y) >> 1;
}
}
}
}
signed main() {
read(n);
read(m);
for (long long i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (long long j = 1; j <= m; j++) {
long long now = 0;
for (long long i = 1; i <= n; i++) now = now << 1 | (s[i][j] - '0');
f[now]++;
}
N = 1 << n;
for (long long i = 0; i < N; i++) {
long long cnt = 0;
for (long long j = 0; j < n; j++) cnt += (i >> j) & 1;
g[i] = min(cnt, n - cnt);
}
FWT(f);
FWT(g);
for (long long i = 0; i < N; i++) f[i] *= g[i];
IFWT(f);
long long ans = inf;
for (long long i = 0; i < N; i++) ans = min(ans, f[i]);
printf("%lld\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
bool vis[N];
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n, m;
vector<int> bian, dian;
scanf("%d %d", &n, &m);
for (int i = 1; i <= 3 * n; i++) vis[i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
if (!vis[u] && !vis[v]) {
vis[u] = 1;
vis[v] = 1;
bian.push_back(i);
}
}
if (bian.size() >= n) {
printf("Matching\n");
for (int i = 0; i < n; i++) printf("%d ", bian[i]);
printf("\n");
continue;
}
printf("IndSet\n");
for (int i = 1, j = 0; i <= 3 * n && j < n; i++) {
if (!vis[i]) printf("%d ", i), j++;
}
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int rem = b % n;
int sum = a + rem;
if (sum <= 0)
cout << n + sum;
else if (sum > n)
cout << sum - n;
else
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n % 2 == 0) {
int num = n / 2;
printf("%d\n", num);
for (int i = 0; i < num; i++)
if (i == num - 1)
printf("2\n");
else
printf("2 ");
} else {
int num = n / 2;
printf("%d\n", num);
for (int i = 0; i < num; i++) {
if (i == num - 1)
printf("3\n");
else
printf("2 ");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double a[500][500], b[500];
int n, m, S0, S1;
bool g[22][22];
int deg[22];
double p[22];
double trans[22][22];
double T[500][500];
int ans[22];
int main() {
scanf("%d%d%d%d", &n, &m, &S0, &S1);
S0--;
S1--;
if (S0 == S1) {
for (int i = 0; i < n; i++) printf("%.9lf ", (S0 == i) * 1.0);
return 0;
}
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
g[u][v] = g[v][u] = true;
deg[u]++;
deg[v]++;
}
for (int i = 0; i < n; i++) scanf("%lf", p + i);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == j)
trans[i][i] = p[i];
else if (g[i][j])
trans[i][j] = (1 - p[i]) / deg[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int u = 0; u < n; u++)
for (int v = 0; v < n; v++) {
if (i == j) {
T[(n * (i) + (j))][(n * (u) + (v))] = 0.0;
} else
T[(n * (i) + (j))][(n * (u) + (v))] = trans[i][u] * trans[j][v];
}
int N = n * n + 1;
for (int i = 0; i < N - 1; i++) {
a[i][i] = 1.0;
for (int j = 0; j < N - 1; j++) a[i][j] -= T[j][i];
}
a[N - 1][N - 1] = 1;
a[N - 1][N] = 1;
for (int i = 0; i < N - 1; i++) a[i][N - 1] -= T[(n * (S0) + (S1))][i];
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++)
if (abs(a[j][i]) > abs(a[i][i]))
for (int k = i; k < N + 1; k++) swap(a[i][k], a[j][k]);
for (int j = i + 1; j < N; j++) {
double c = a[j][i] / a[i][i];
for (int k = i; k < N + 1; k++) a[j][k] -= c * a[i][k];
}
}
for (int i = N - 1; i >= 0; i--) {
b[i] = a[i][N] / a[i][i];
for (int j = i - 1; j >= 0; j--) a[j][N] -= b[i] * a[j][i];
}
for (int i = 0; i < n; i++) printf("%.9lf ", b[(n * (i) + (i))]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void FIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const long long mxN = 2e5 + 2;
long long n, a[mxN], dp1[mxN], dp2[mxN], l[mxN];
vector<long long> adj[mxN + 1];
void dfs(long long v = 1, long long p = 0) {
l[v] = (adj[v].size() == 0);
dp2[v] += a[v];
for (long long x : adj[v]) {
dfs(x, v);
l[v] += l[x];
dp2[v] += dp2[x];
dp1[v] = max(dp1[x], dp1[v]);
}
dp1[v] = max(dp1[v], (dp2[v] + l[v] - 1) / l[v]);
}
signed main() {
FIO();
cin >> n;
for (long long i = 0, p; i < n - 1; i++) {
cin >> p;
adj[p].push_back(i + 2);
}
for (long long i = 1; i <= n; i++) cin >> a[i];
dfs();
cout << dp1[1];
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 1e6 + 5;
using namespace std;
int rd() {
int x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x;
}
int n, head[maxn], tot, a, b, c, d, Node, fa[maxn];
int sz[maxn], vis[maxn], cnt[2][maxn];
vector<int> vec;
bitset<maxn / 2> dp;
struct node {
int v, nxt;
} e[maxn << 1];
void add(int u, int v) {
e[++tot].v = v;
e[tot].nxt = head[u];
head[u] = tot;
}
void dfs(int u, int y) {
bool flag = true;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == y) continue;
fa[v] = u;
flag = false;
dfs(v, u);
sz[u] += sz[v];
}
if (flag) sz[u] = 1;
}
void work(int &u, int num) {
vis[u] = 1;
while (fa[u] ^ 1) {
u = fa[u];
vis[u] = 1;
for (int i = head[u]; i; i = e[i].nxt)
if (e[i].v != fa[u] && !vis[e[i].v]) ++cnt[num][sz[e[i].v]];
}
}
bool check(int num, int A) {
if (sz[A] > Node) return false;
vec.clear();
dp.reset();
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int p = 1;
while (cnt[num][i] >= p) {
cnt[num][i] -= p;
vec.push_back(i * p);
p <<= 1;
}
if (cnt[num][i]) vec.push_back(i * cnt[num][i]);
}
for (int i = 0; i < ((int)vec.size()); i++) dp |= dp << vec[i];
return dp[Node - sz[A]];
}
int main() {
n = rd();
a = rd();
b = rd();
c = rd();
d = rd();
for (int i = 2, u; i <= n; i++) {
u = rd();
add(u, i);
}
dfs(1, 0);
if (sz[1] & 1) {
puts("No");
return 0;
}
Node = sz[1] / 2 - 1;
work(a, 0);
work(b, 0);
work(c, 1);
work(d, 1);
if (a == b || c == d) {
puts("No");
return 0;
}
for (int i = head[1]; i; i = e[i].nxt)
if (!vis[e[i].v]) ++cnt[0][sz[e[i].v]], ++cnt[1][sz[e[i].v]];
if (!check(0, c)) {
puts("No");
return 0;
}
if (!check(1, a)) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void runtime() {
cout << fixed << setprecision(5) << 1.0 * clock() / CLOCKS_PER_SEC << endl;
}
template <class T>
void read(vector<T> &a, int n) {
T x;
a.clear();
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
}
template <class T>
void write(vector<T> &a) {
for (T x : a) cout << x << ' ';
cout << '\n';
}
const int N = 404;
using cd = complex<double>;
const double PI = acos(-1.0);
vector<cd> prec_w;
int lg;
void precomp(int need_lg) {
if (prec_w.size() >= (1 << need_lg) + 1) return;
lg = need_lg;
prec_w.clear();
cd w(1, 0);
double ang = 2 * PI / (1 << need_lg);
cd wlen(cos(ang), sin(ang));
while (prec_w.size() != (1 << need_lg) + 1) {
prec_w.push_back(w);
w *= wlen;
}
}
void fft(vector<cd> &a, bool invert = 0) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int cur_lg = 1; (1 << cur_lg) <= n; cur_lg++)
for (int i = 0; i < n; i += (1 << cur_lg))
for (int j = 0; j < (1 << (cur_lg - 1)); j++) {
cd u = a[i + j];
cd v = a[i + j + (1 << (cur_lg - 1))] *
prec_w[invert ? ((1 << lg) - (1 << (lg - cur_lg)) * j)
: (1 << (lg - cur_lg)) * j];
a[i + j] = u + v;
a[i + j + (1 << (cur_lg - 1))] = u - v;
}
if (invert)
for (int i = 0; i < n; i++) a[i] /= n;
}
vector<cd> mult(vector<cd> &a, vector<cd> &b) {
vector<cd> res;
vector<cd> fa(a.begin(), a.end());
vector<cd> fb(b.begin(), b.end());
int n = 1;
while (n < (int)a.size() + (int)b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
res.resize(n);
fft(fa);
fft(fb);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, 1);
for (int i = 0; i < fa.size(); i++) res[i] = (int)(fa[i].real() + 1e-4);
return res;
}
vector<cd> get_scalar(vector<cd> &a, vector<cd> &b) {
vector<cd> ans;
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
for (int i = (int)b.size() - 1; i < a.size(); i++) ans.push_back(res[i]);
return ans;
}
vector<cd> get(string second, string t) {
vector<cd> a, b;
for (int i = 0; i < second.size(); i++) {
double alp = PI * (second[i] - 'a') / 26;
a.push_back(cd(cos(alp), sin(alp)));
}
for (int i = 0; i < t.size(); i++) {
if (t[i] >= 'a' && t[i] <= 'z') {
double alp = PI * (t[i] - 'a') / 26;
b.push_back(cd(cos(alp), -sin(alp)));
} else
b.push_back(cd(0, 0));
}
return get_scalar(a, b);
}
int n, m, r, c;
string a[N], b[N];
string second, t;
vector<string> v;
int cnt;
int main() {
ios_base::sync_with_stdio(0);
precomp(20);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
cin >> r >> c;
for (int i = 0; i < r; i++) {
cin >> b[i];
for (int j = 0; j < b[i].size(); j++)
if (b[i][j] == '?') cnt++;
}
for (int i = 0; i < v.size(); i++) {
string ss = v[i];
while (v[i].size() < m + c) v[i] += ss;
}
int pos = 0;
while (v.size() < n + r) {
v.push_back(v[pos % n]);
pos++;
}
int w = (int)v[0].size();
for (string x : v) second += x;
for (int i = 0; i < r; i++) {
t += b[i];
for (int j = (int)b[i].size(); j < w; j++) t += "#";
}
vector<cd> kilk = get(second, t);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (kilk[i * w + j].real() + cnt == r * c)
cout << 1;
else
cout << 0;
cout << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, l[100] = {0};
char word[100][100];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("\n%[^\n]", word[i]);
if (strlen(word[i]) > 10) l[i] = strlen(word[i]) - 2;
}
for (int i = 0; i < n; i++) {
if (l[i] > 8)
printf("%c%d%c\n", word[i][0], l[i], word[i][l[i] + 1]);
else
puts(word[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, a[N];
void read_input() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
}
void solve() {
a[0] = 1;
sort(a, a + n + 1);
a[n + 1] = a[n];
if (a[k] == a[k + 1] && k < n || k == 0 && a[1] == 1)
cout << -1;
else
cout << a[k];
}
void write_output() {}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
read_input(), solve(), write_output();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int isSquare(long n);
int main(int argc, const char* argv[]) {
string str;
int n, m, sum = 0;
long long max = INT64_MIN;
long long min = INT64_MAX;
int c = 0, x, f = 0;
;
vector<int> stairs;
map<int, int> map;
long double arr[6];
for (int i = 0; i < 6; i++) {
cin >> arr[i];
sum += arr[i];
}
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
for (int k = 0; k < 6; k++) {
if (i != k && j != k && i != j) {
if ((sum - arr[i] - arr[j] - arr[k]) == arr[i] + arr[j] + arr[k]) {
cout << "YES " << endl;
return 0;
}
}
}
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
a = a % 4;
long long b, c, d;
long long ile[3];
cin >> b >> c >> d;
if (a == 0) {
cout << 0 << endl;
exit(0);
}
if (a == 1) {
ile[0] = 3 * b;
ile[1] = b + c;
ile[2] = d;
sort(ile, ile + 3);
cout << ile[0] << endl;
}
if (a == 2) {
ile[0] = 2 * b;
ile[1] = c;
ile[2] = 2 * d;
sort(ile, ile + 3);
cout << ile[0] << endl;
}
if (a == 3) {
ile[0] = b;
ile[1] = c + d;
ile[2] = 3 * d;
sort(ile, ile + 3);
cout << ile[0] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct cs {
int to, next;
} a[200001];
int aa[400001], head[100001], sum[100001];
bool vi[100001], c[100001];
int n, m, z, y, x, ans, ll, S;
void init(int x, int y) {
a[++ll].to = y;
a[ll].next = head[x];
head[x] = ll;
}
void dfs(int x, int y) {
vi[x] = 1;
aa[++ans] = x;
sum[x]++;
for (int k = head[x]; k; k = a[k].next)
if (!vi[a[k].to]) {
dfs(a[k].to, x);
aa[++ans] = x;
sum[x]++;
}
if (bool(sum[x] & 1) != c[x]) {
aa[++ans] = y;
sum[y]++;
aa[++ans] = x;
sum[x]++;
}
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &x, &y);
init(x, y);
init(y, x);
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
if (c[i]) S = i;
}
if (S) {
dfs(S, -1);
for (int i = 1; i <= n; i++)
if (!vi[i] && c[i]) {
printf("-1");
return 0;
}
}
if (ans > 1 && aa[ans - 1] == -1) ans -= 3;
printf("%d\n", ans);
for (int i = 1; i <= ans; i++) printf("%d ", aa[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int MAXB = 340;
deque<int> q[MAXB];
int BL, n, lasans, cnt[MAXB][MAXN], bl[MAXN], st[MAXB], en[MAXB];
int main() {
cin >> n;
BL = int(sqrt(n));
for (int i = 0; i < n; i++) {
bl[i] = i / BL;
if (!st[bl[i]]) st[bl[i]] = i;
en[bl[i]] = i;
int x;
cin >> x;
cnt[bl[i]][x]++;
q[bl[i]].push_back(x);
}
int Q;
cin >> Q;
while (Q--) {
int op, l, r, x, y, k;
cin >> op >> l >> r;
l = (l + lasans - 1) % n + 1;
r = (r + lasans - 1) % n + 1;
if (l > r) swap(l, r);
l--;
x = l / BL;
y = r / BL;
if (op == 1) {
if (x == y) {
l %= BL;
r = r % BL - 1;
int num = q[x][r];
q[x].erase(q[x].begin() + r);
q[x].insert(q[x].begin() + l, num);
} else {
for (int i = x; i < y; i++) {
int num = q[i].back();
cnt[i][num]--;
q[i].pop_back();
q[i + 1].push_front(num);
cnt[i + 1][num]++;
}
r %= BL;
int num = q[y][r];
q[y].erase(q[y].begin() + r);
cnt[y][num]--;
q[x].insert(q[x].begin() + l % BL, num);
cnt[x][num]++;
}
} else {
cin >> k;
k = (k + lasans - 1) % n + 1;
if (x == y) {
lasans = 0;
for (int i = l % BL; i < r % BL; i++) lasans += q[x][i] == k;
} else {
lasans = 0;
for (int i = x + 1; i < y; i++) lasans += cnt[i][k];
for (int i = l % BL; i < q[x].size(); i++) lasans += q[x][i] == k;
for (int i = 0; i < r % BL; i++) lasans += q[y][i] == k;
}
cout << lasans << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, d, c[55];
int can[55 * 10000], sum = 0;
int main() {
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> c[i];
sum += c[i];
}
can[0] = 1;
for (int i = 0; i < n; i++)
for (int j = sum - c[i]; j >= 0; j--)
if (can[j]) can[j + c[i]] = 1;
int mx = 0, nmx = 0, ans = 0;
while (1) {
mx = nmx;
for (int i = mx + 1; i <= min(sum, mx + d); i++)
if (can[i]) nmx = i;
if (mx == nmx) break;
mx = nmx;
ans++;
}
cout << mx << " " << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double p[220];
int a[220];
double dp[220][220][450];
int n, l, k;
double ans = 0;
double dyn(int n, int l, int k) {
if (k < -210 || l < 0) return 0.0;
if (k > 210) k = 210;
if (dp[n][l][k + 210] != -1) return dp[n][l][k + 210];
if (n == 0) {
if (l == 0 && k == 0)
return 1.0;
else
return 0.0;
}
return dp[n][l][k + 210] = (dyn(n - 1, l, k) * (1 - p[n - 1])) +
(dyn(n - 1, l - 1, k - a[n - 1]) * p[n - 1]);
}
int main() {
cin >> n >> l >> k;
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i] /= 100.0;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
dp[0][0][210] = 1.0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int w = -210; w <= 210; w++) {
dp[i + 1][j + 1][min(420, w + a[i] + 210)] += dp[i][j][w + 210] * p[i];
dp[i + 1][j][w + 210] += dp[i][j][w + 210] * (1 - p[i]);
}
}
}
for (int i = l; i <= n; i++) {
for (int j = -k; j <= 210; j++) {
ans += dp[n][i][j + 210];
}
}
printf("%lf", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 1e5 + 5;
vector<int> par;
vector<int> s;
vector<int> adj[nax];
vector<int> a;
vector<bool> vis;
bool flag = true;
bool check(vector<int>& v, long long int prev_sum) {
sort(v.begin(), v.end());
if (v[0] >= prev_sum)
return true;
else
return false;
}
void dfs(int u, long long int prev_sum) {
vector<int> child;
vis[u] = true;
for (int v : adj[u]) {
if (!vis[v]) {
if (s[u] == -1) {
child.push_back(s[v]);
}
dfs(v, s[u]);
}
}
if (s[u] == -1) {
if (child.size() == 0)
s[u] = prev_sum;
else {
if (check(child, prev_sum)) {
s[u] = child[0];
} else
flag = false;
}
}
}
void dfs2(int u, long long int& sum, long long int prev_sum) {
sum += s[u] - prev_sum;
vis[u] = true;
for (int v : adj[u]) {
if (!vis[v]) {
dfs2(v, sum, s[u]);
}
}
}
long long int solve(int n) {
vis = vector<bool>(n + 1, false);
dfs(1, 0);
a = vector<int>(n + 1);
if (!flag) return -1;
vis = vector<bool>(n + 1, false);
long long int sum = 0;
dfs2(1, sum, 0);
return sum;
}
int main() {
int n;
cin >> n;
par = vector<int>(n + 1);
s = vector<int>(n + 1);
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
adj[i].push_back(p);
adj[p].push_back(i);
}
for (int i = 1; i <= n; i++) cin >> s[i];
cout << solve(n) << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class Group {
public:
int A[6];
Group(int x1, int y1, int x2, int y2, int x3, int y3) {
A[0] = x1;
A[1] = y1;
A[2] = x2;
A[3] = y2;
A[4] = x3;
A[5] = y3;
}
};
void invert(Group& g, vector<string>& A) {
constexpr char z = '0' + '1';
for (int i = 0; i < 6; i += 2)
A[g.A[i]][g.A[i + 1]] = z - A[g.A[i]][g.A[i + 1]];
}
void solve() {
int N, M;
cin >> N >> M;
vector<string> A(N);
for (auto& a : A) cin >> a;
vector<Group> answer;
for (int i = N - 1; i >= 2; --i) {
for (int j = 1; j < M; ++j) {
if (A[i][j] == '1') {
answer.emplace_back(i, j, i - 1, j, i - 1, j - 1);
invert(answer[answer.size() - 1], A);
}
}
if (A[i][0] == '1') {
answer.emplace_back(i, 0, i - 1, 0, i - 1, 1);
invert(answer[answer.size() - 1], A);
}
}
for (int j = M - 1; j >= 1; --j) {
for (int i = 0; i < 2; ++i) {
if (A[i][j] == '1') {
answer.emplace_back(i, j, 0, j - 1, 1, j - 1);
invert(answer[answer.size() - 1], A);
}
}
}
if (A[0][0] == '0' && A[1][0] == '1') {
answer.emplace_back(0, 0, 1, 0, 1, 1);
invert(answer[answer.size() - 1], A);
answer.emplace_back(0, 0, 1, 0, 0, 1);
invert(answer[answer.size() - 1], A);
answer.emplace_back(1, 1, 1, 0, 0, 1);
invert(answer[answer.size() - 1], A);
} else if (A[0][0] == '1' && A[1][0] == '0') {
answer.emplace_back(0, 0, 1, 0, 1, 1);
invert(answer[answer.size() - 1], A);
answer.emplace_back(0, 0, 1, 0, 0, 1);
invert(answer[answer.size() - 1], A);
answer.emplace_back(1, 1, 0, 0, 0, 1);
invert(answer[answer.size() - 1], A);
} else if (A[0][0] == '1' && A[1][0] == '1') {
answer.emplace_back(1, 1, 0, 0, 0, 1);
invert(answer[answer.size() - 1], A);
answer.emplace_back(1, 1, 1, 0, 0, 1);
invert(answer[answer.size() - 1], A);
}
cout << answer.size() << endl;
for (auto& a : answer) {
for (int i = 0; i < 5; ++i) cout << a.A[i] + 1 << " ";
cout << a.A[5] + 1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
void solve(int TestCase) {
string s;
cin >> s;
reverse(s.begin(), s.end());
s.push_back('0');
int n = s.size();
int max_cnt = 5 * n + 1;
int max_carry = 5 * n / 9 + 1;
auto dp = vvvi(max_carry * 2 + 1, vvi(max_cnt, vi(max_cnt, INT_MAX)));
for(auto i = 0; i < max_cnt; ++i) for(auto j = 0; j < max_cnt; ++j)
dp[max_carry][i][j] = 0;
for(auto i = 0; i < n; ++i) {
auto ndp = vvvi(max_carry * 2 + 1, vvi(max_cnt, vi(max_cnt, INT_MAX)));
for(auto carry = 0; carry < dp.size(); ++carry) {
for(auto j = max_cnt - 1; j >= 0; --j) for(auto k = max_cnt - 1; k >= 0; --k) {
if(dp[carry][j][k] == INT_MAX) continue;
int rcarry = carry - max_carry;
int val = rcarry + j - k;
int d = (val % 10 + 10) % 10;
int ncarry = val / 10 + max_carry;
if(s[i] - '0' != d) continue;
if (val < 0 && d != 0) --ncarry;
ndp[ncarry][j][k] = min(ndp[ncarry][j][k], dp[carry][j][k] + j + k);
}
}
for(auto carry = 0; carry < dp.size(); ++carry) {
for(auto j = max_cnt - 1; j >= 0; --j) for(auto k = max_cnt - 1; k >= 0; --k) {
if(k+1 < max_cnt)
ndp[carry][j][k] = min(ndp[carry][j][k], ndp[carry][j][k+1]);
if(j+1 < max_cnt)
ndp[carry][j][k] = min(ndp[carry][j][k], ndp[carry][j+1][k]);
}
}
swap(dp, ndp);
}
auto ret = dp[max_carry][0][0];
cout << ret << endl;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
//cin >> t;
for(auto i = 1; i <= t; ++i) {
//cout << "Case #"<< i << ": ";
solve(i);
}
} | 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010, D = 510;
int n, m, k, t[N];
int x[N], y[N];
bool f[D][D];
int de[3];
char s[N];
int a[D][D];
using namespace std;
void u(int ti, int i, int j) {
t[++k] = ti;
x[k] = i;
y[k] = j;
}
void dfs(int i, int j);
void moze(int i, int j) {
if (i > 0 && i <= n && j > 0 && j <= m && a[i][j] && !f[i][j]) {
dfs(i, j);
u(2, i, j);
u(3, i, j);
}
}
void dfs(int i, int j) {
u(1, i, j);
f[i][j] = true;
moze(i - 1, j);
moze(i, j - 1);
moze(i, j + 1);
moze(i + 1, j);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (int j = 1; j <= m; j++)
if (s[j] == '.') a[i][j] = 1;
}
de[1] = 1;
de[2] = -1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j] && !f[i][j]) dfs(i, j);
printf("%d\n", k);
for (int i = 1; i <= k; i++) {
if (t[i] == 1)
printf("B ");
else if (t[i] == 2)
printf("D ");
else
printf("R ");
printf("%d %d\n", x[i], y[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
const int maxn(200005);
using namespace std;
long long n, p;
long long Time;
struct people {
long long t, pos, end;
} P[maxn];
bool cmp(const people& a, const people& b) {
return a.t == b.t ? a.pos < b.pos : a.t < b.t;
}
long long ans[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> p;
for (int i = 0; i <= n - 1; ++i) {
cin >> P[i].t;
P[i].pos = i;
}
sort(P, P + n, cmp);
int last = n;
priority_queue<long long, vector<long long>, greater<long long> > qpos;
int q = -1;
Time = 0;
int l = 0;
while (l < n) {
if (q != -1) {
ans[q] = Time + p;
Time += p;
last = q;
q = -1;
} else if (P[l].t <= Time) {
if (P[l].pos < last)
q = P[l].pos;
else
qpos.push(P[l].pos);
l++;
} else {
if (!qpos.empty()) {
int pos = qpos.top();
qpos.pop();
ans[pos] = Time + p;
Time += p;
last = pos;
} else {
Time = P[l].t;
last = n;
}
}
}
if (q != -1) Time += p, ans[q] = Time;
while (!qpos.empty()) {
int pos = qpos.top();
qpos.pop();
Time += p;
ans[pos] = Time;
}
for (int i = 0; i <= n - 1; ++i) cout << ans[i] << " \n"[i == n - 1];
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int INF = 2147483647;
const int mod = 1000000007;
const int mod2 = 998244353;
const double eps = 1e-9;
const double pi = acos(-1.0);
inline int rint() {
int x;
scanf("%d", &x);
return x;
}
inline long long rll() {
long long x;
scanf("%lld", &x);
return x;
}
inline long long ri64() {
long long x;
scanf("%I64d", &x);
return x;
}
void rvi(vector<int> &a, int n) {
for (int i = 0; i < n; i++) {
a.push_back(rint());
}
}
void rvll(vector<long long> &a, int n) {
for (int i = 0; i < n; i++) {
a.push_back(rll());
}
}
void showvi(vector<int> &a) {
for (int i = 0; i < a.size(); i++) {
printf("%d%c", a[i], (i + 1 == a.size() ? '\n' : ' '));
}
}
void showvll(vector<long long> &a) {
for (int i = 0; i < a.size(); i++) {
printf("%lld%c", a[i], (i + 1 == a.size() ? '\n' : ' '));
}
}
void showviln(vector<int> &a) {
for (int i = 0; i < a.size(); i++) {
printf("%d%c", a[i], '\n');
}
}
void showvllln(vector<long long> &a) {
for (int i = 0; i < a.size(); i++) {
printf("%lld%c", a[i], '\n');
}
}
void showi(int x) { printf("%d", x); }
long long pw(long long a, long long b, long long c) {
long long ans = 1;
long long k = a % c;
while (b > 0) {
if (b % 2 == 1) ans = (ans * k) % c;
b = b / 2;
k = (k * k) % c;
}
return ans;
}
const int maxn = 100011;
struct node {
double x, y;
};
int n;
int tot;
node p[maxn];
node P[maxn];
int tot2;
node P2[maxn];
double X(node A, node B, node C) {
return (B.x - A.x) * (C.y - A.y) - (C.x - A.x) * (B.y - A.y);
}
double dian(node A, node B, node C) {
return (B.x - A.x) * (C.x - A.x) + (C.y - A.y) * (B.y - A.y);
}
double len(node A, node B) {
return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
}
bool cmp(node A, node B) {
double pp = X(p[0], A, B);
if (pp > 0) return true;
if (pp < 0) return false;
if (pp == 0) return len(p[0], A) < len(p[0], B);
}
void build() {
for (int i = 0; i < n; i++) {
if (p[i].y < p[0].y) swap(p[i], p[0]);
if (p[i].y == p[0].y && p[i].x < p[0].x) swap(p[i], p[0]);
}
sort(p + 1, p + n, cmp);
P[0] = p[0];
P[1] = p[1];
tot = 1;
for (int i = 2; i < n; i++) {
while (tot > 0 && X(P[tot - 1], P[tot], p[i]) <= 0) tot--;
tot++;
P[tot] = p[i];
}
tot++;
}
int x1[100011];
int asdfeawf[100011];
int x2[100011];
int y2[100011];
int a[400044];
int b[400044];
int ha[400044];
int hb[400044];
int pwb[400044];
const int hmod = 1000000007;
const int mmod = 998244353;
const int base = 233;
int dis(int x1, int asdfeawf, int x2, int y2) {
int ans = 1LL * (x1 - x2) * (x1 - x2) % mmod +
1LL * (asdfeawf - y2) * (asdfeawf - y2) % mmod;
if (ans >= mmod) ans -= mmod;
return ans;
}
void work() {
for (int i = 0; i < (tot); i++) {
x1[i] = P[i].x + 0.1;
asdfeawf[i] = P[i].y + 0.1;
}
for (int i = 0; i < (tot2); i++) {
x2[i] = P2[i].x + 0.1;
y2[i] = P2[i].y + 0.1;
}
if (tot != tot2) {
cout << "NO" << '\n';
return;
}
for (int i = 0; i < (tot); i++) {
int X0 = x1[(i - 1 + tot) % tot];
int Y0 = asdfeawf[(i - 1 + tot) % tot];
int X1 = x1[i];
int Y1 = asdfeawf[i];
int X2 = x1[(((i) + 1) % (tot))];
int Y2 = asdfeawf[(((i) + 1) % (tot))];
int len0 = dis(X0, Y0, X1, Y1);
int len1 = dis(X1, Y1, X2, Y2);
a[2 * i + 1] = a[2 * i + 2 * tot + 1] = len1;
int VX0 = X0 - X1;
long long VY0 = Y0 - Y1;
int VX1 = X2 - X1;
long long VY1 = Y2 - Y1;
if (VX0 < 0) VX0 += mmod;
if (VX1 < 0) VX1 += mmod;
if (VY1 < 0) VY1 += mmod;
if (VY0 < 0) VY0 += mmod;
int DOT = (1LL * VX0 * VX1 % mmod + 1LL * VY0 * VY1 % mmod);
if (DOT >= mmod) DOT -= mod;
int MUL = 1LL * len0 * len1 % mmod;
int ANG = 1LL * DOT * pw(MUL, mmod - 2, mmod) % mmod;
a[2 * i] = a[2 * i + 2 * tot] = ANG;
}
for (int i = 0; i < (tot); i++) {
int X0 = x2[(i - 1 + tot) % tot];
int Y0 = y2[(i - 1 + tot) % tot];
int X1 = x2[i];
int Y1 = y2[i];
int X2 = x2[(((i) + 1) % (tot))];
int Y2 = y2[(((i) + 1) % (tot))];
int len0 = dis(X0, Y0, X1, Y1);
int len1 = dis(X1, Y1, X2, Y2);
b[2 * i + 1] = b[2 * i + 2 * tot + 1] = len1;
int VX0 = X0 - X1;
long long VY0 = Y0 - Y1;
int VX1 = X2 - X1;
long long VY1 = Y2 - Y1;
if (VX0 < 0) VX0 += mmod;
if (VX1 < 0) VX1 += mmod;
if (VY1 < 0) VY1 += mmod;
if (VY0 < 0) VY0 += mmod;
int DOT = (1LL * VX0 * VX1 % mmod + 1LL * VY0 * VY1 % mmod);
if (DOT >= mmod) DOT -= mod;
int MUL = 1LL * len0 * len1 % mmod;
int ANG = 1LL * DOT * pw(MUL, mmod - 2, mmod) % mmod;
b[2 * i] = b[2 * i + 2 * tot] = ANG;
}
for (int i = 0; i < (4 * tot); i++) {
ha[i] = 0;
if (i) ha[i] = 1LL * ha[i - 1] * base % hmod;
ha[i] = (ha[i] + a[i]);
if (ha[i] >= hmod) ha[i] -= hmod;
hb[i] = 0;
if (i) hb[i] = 1LL * hb[i - 1] * base % hmod;
hb[i] = (hb[i] + b[i]);
if (hb[i] >= hmod) hb[i] -= hmod;
}
int h1 = ha[2 * tot - 1];
for (int i = 0; i < 2 * tot; i += 2) {
int l = i;
int r = i + 2 * tot - 1;
int h2 = hb[r];
if (l > 0) h2 = h2 - 1LL * hb[l - 1] * pwb[r - l + 1] % hmod;
if (h2 < 0) h2 += hmod;
if (h1 == h2) {
cout << "YES" << '\n';
return;
}
}
cout << "NO" << '\n';
}
int main() {
pwb[0] = 1;
for (int i = 1; i < 400044; i++) pwb[i] = 1LL * pwb[i - 1] * base % hmod;
int n1, n2;
scanf("%d%d", &n1, &n2);
tot = 0;
n = n1;
for (int i = 0; i < (n1); i++) {
p[i].x = rint();
p[i].y = rint();
}
build();
for (int i = 0; i < (tot); i++) {
P2[i].x = P[i].x;
P2[i].y = P[i].y;
}
tot2 = tot;
tot = 0;
n = n2;
for (int i = 0; i < (n2); i++) {
p[i].x = rint();
p[i].y = rint();
}
build();
work();
}
| 8 |
#include <bits/stdc++.h>
long long gcd(long long a, long long b) {
if (!b) {
return a;
}
return gcd(b, a % b);
}
bool arr[1000001];
using namespace std;
long long brr[1005];
long long state[100005];
int32_t main() {
long long n, m, h;
cin >> n >> m >> h;
long long arr[m];
for (long long i = 0; i < m; i++) {
cin >> arr[i];
}
long long brr[n];
for (long long i = 0; i < n; i++) {
cin >> brr[i];
}
long long crr[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> crr[i][j];
}
}
for (long long i = 0; i < n; i++) {
long long x = brr[i];
for (long long j = 0; j < m; j++) {
long long y = arr[j];
if (crr[i][j] == 1) {
crr[i][j] = min(x, y);
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << crr[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define fort(i,a,b) for(long long i=a;i<=b;i++)
#define forn(i,a,b) for(long long i=a;i>=b;i--)
#define rep(i,a,b) for(long long i=a;i<b;i++)
#define x first
#define y second
#define pb push_back
#define MP make_pair
using namespace std;
const long long N=2e5+5;
long long s1,s2,d,c,test,n,l[N][20],f[N],kq[N],h[N],cnt[N],kt[N],timer,tin[N],tout[N];
vector<long long > a[N];
void dfs(long long u,long long pa)
{
tin[u]=++timer;
h[u]=h[pa]+1;
l[u][0]=pa;
cnt[u]++;
for(long long v:a[u])
if (v!=pa)
{
dfs(v,u);
f[u]+=cnt[u]*cnt[v];
cnt[u]+=cnt[v];
}
f[u]+=(n-cnt[u])*cnt[u];
tout[u]=++timer;
}
void build_lca()
{
fort(i,1,log2(n))
fort(j,1,n)
l[j][i]=l[l[j][i-1]][i-1];
}
long long lca(long long u,long long v)
{
if (h[u]<h[v]) swap(u,v);
forn(i,log2(h[u]),0)
if (h[l[u][i]]>=h[v]) u=l[u][i];
if (u==v) return u;
forn(i,log2(h[u]),0)
if (l[u][i]!=l[v][i])
{
u=l[u][i];
v=l[v][i];
}
return l[u][0];
}
void chinh(long long x)
{
if (kt[x]) return;
kt[x]=1;
chinh(l[x][0]);
}
bool con(long v,long u)
{
return tin[u]<tin[v]&&tout[v]<tout[u];
}
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin>>test;
while (test--)
{
cin>>n;
fort(i,1,n-1)
{
long long u,v;
cin>>u>>v;
u++;v++;
a[u].pb(v);
a[v].pb(u);
}
dfs(1,0);
build_lca();
kq[1]=n*(n-1)/2-f[1];
kq[n+1]=1;
fort(i,1,n)
if (a[i].size()>2) kq[n+1]=0;
d=1;c=1;s1=0;s2=0;
kt[1]=1;
fort(i,2,n)
if (!kt[i])
{
if (d!=c)
{
if (c==1)
{
if (lca(i,d)!=1&&lca(i,d)!=d&&kt[lca(i,d)])
{
kq[i]=s2*cnt[d];
break;
}
} else
{
if (lca(i,d)!=d&&lca(i,c)!=c)
{
kq[i]=cnt[d]*cnt[c];
break;
}
}
if (con(i,d))
{
chinh(i);
s1=cnt[d]-cnt[i];
kq[i]=s1*s2;
d=i;
s1=cnt[d];
} else
if (con(i,c))
{
chinh(i);
if (c==1) s2-=cnt[i];else
s2=cnt[c]-cnt[i];
kq[i]=s1*s2;
c=i;
s2=cnt[c];
}
} else
{
chinh(i);
for(long long v:a[1])
if (!kt[v]) s2+=cnt[v];
s2++;s1=cnt[i];
kq[i]=f[1]-cnt[i]*s2;
d=i;
}
}
fort(i,1,n+1) cout<<kq[i]<<' ';cout<<'\n';
fort(i,1,n) a[i].clear();
fort(i,1,n+1) kq[i]=0;
fort(i,1,n) cnt[i]=0;
fort(i,1,n)
fort(j,0,log2(n)) l[i][j]=0;
fort(i,1,n) kt[i]=0;
fort(i,1,n) f[i]=0;
timer=0;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
const ll N = 1e5 + 10;
const ll INF = 1e10;
const ll M = 1e3 + 1;
const ll mod = 1e9 + 7;
const ll L = 31;
ll solve() {
ll n, k;
cin >> n >> k;
ll arr[n];
ll mx = -1e10, mi = 1e10;
for (ll i = 0; i < n; i++) {
cin >> arr[i];
mx = max(mx, arr[i]);
mi = min(mi, arr[i]);
}
for (ll i = 0; i < n; i++) {
arr[i] = mx - arr[i];
}
k--;
if ((k % 2) == 1) {
for (ll i = 0; i < n; i++) {
arr[i] = (mx - mi) - arr[i];
}
}
for (ll i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << '\n';
return 0;
}
signed main() {
ll cas;
cin >> cas;
for (ll i = 0; i < cas; i++) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, a[5000], num_under[5000], dp[5000][5000], ps[5001][5001];
int mul(int x, int y) { return ((long long)x * y) % mod; }
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
num_under[i] = num_under[i - 1];
while (2 * a[num_under[i]] <= a[i]) {
++num_under[i];
}
}
for (int i = 0; i < n; i++) {
dp[0][i] = 1;
ps[0][i + 1] = i + 1;
}
for (int i = 1; i < n; i++) {
for (int j = i; j < n; j++) {
dp[i][j] =
(ps[i - 1][num_under[j]] + mul(dp[i - 1][j], num_under[j] - i + 1)) %
mod;
}
for (int j = 0; j < n; j++) {
ps[i][j + 1] = (ps[i][j] + dp[i][j]) % mod;
}
}
cout << dp[n - 1][n - 1] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
const int N = 500000 + 19;
struct node {
long long val;
int isA;
bool operator<(const node &B) const {
return val > B.val || val == B.val && isA < B.isA;
}
};
priority_queue<node> Q;
int A[N], B[N];
int n, K, cnt, l, r;
long long res, sum;
void calc(int delta) {
sum = 0, cnt = 0;
while (!Q.empty()) Q.pop();
for (int i = 1; i < n + 1; i++) {
Q.push((node){A[i], 1});
node T = Q.top();
if (B[i] - delta + T.val < 0) {
cnt += T.isA;
sum += B[i] - delta + T.val;
Q.pop();
Q.push((node){-(B[i] - delta), 0});
}
}
}
int main() {
n = IN(), K = IN();
for (int i = 1; i < n + 1; i++) A[i] = IN();
for (int i = 1; i < n + 1; i++) B[i] = IN();
l = 0, r = int(2e9);
while (l <= r) {
int mid = (0ll + l + r) / 2;
calc(mid);
if (cnt <= K) {
res = sum + 1ll * cnt * mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << res << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
string s;
cin >> s;
long long ans = 1;
for (long long i = 1; i < n; i++) {
ans += (s[i] != s[i - 1]);
}
cout << min(ans + 2, n);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cnt[100010];
int a[100010];
inline void add(int i, int del) {
while (i <= 100000) {
a[i] += del;
i += (i & (-i));
}
}
inline int query(int i) {
register int res = 0;
while (i) {
res += a[i];
i -= (i & (-i));
}
return res;
}
inline void adc(int c) {
if (cnt[c]) add(cnt[c], -1);
++cnt[c];
add(cnt[c], 1);
}
inline void dec(int c) {
add(cnt[c], -1);
--cnt[c];
if (cnt[c]) add(cnt[c], 1);
}
vector<int> adj[100010];
int clk;
int st[100010], ed[100010];
int dcl[100010];
int clr[100010];
int qv[100010];
int qk[100010];
int res[100010];
void dfs(int i, int fa) {
st[i] = ++clk;
dcl[clk] = clr[i];
for (int j = adj[i].size() - 1; ~j; --j) {
if (adj[i][j] != fa) dfs(adj[i][j], i);
}
ed[i] = clk;
}
pair<pair<int, int>, int> qry[100010];
int main(void) {
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &clr[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &qv[i], &qk[i]);
qry[i] = make_pair(make_pair(st[qv[i]] / 320, ed[qv[i]]), i);
}
sort(&qry[1], &qry[q + 1]);
int l = 1, r = 0;
for (int i = 1; i <= q; ++i) {
int id = qry[i].second, lt = st[qv[id]], rt = ed[qv[id]];
while (l > lt) {
--l;
adc(dcl[l]);
}
while (r < rt) {
++r;
adc(dcl[r]);
}
while (l < lt) {
dec(dcl[l]);
++l;
}
while (r > rt) {
dec(dcl[r]);
--r;
}
res[id] = query(100000) - query(qk[id] - 1);
}
for (int i = 1; i <= q; ++i) {
printf("%d\n", res[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long t, n;
int main() {
cin >> t;
for (int w = 0; w < t; w++) {
cin >> n;
n *= 2;
setprecision(7);
cout << fixed
<< 1 / tan((3.141592653589 / 2) / n) / 2 /
cos((3.141592653589 / 2) / (n))
<< endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> t[1004];
;
int visited[1004][1004];
int main() {
int n, k;
cin >> n >> k;
if (2 * k < n) {
cout << n * k << "\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
cout << i << " " << (i + j - 1) % n + 1 << "\n";
}
}
} else {
cout << "-1\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, m, root, d[N], p[N], h[N];
bool mark[N], good[N];
vector<int> adj[N];
queue<int> q;
bool dfs1(int u) {
int mx = -1;
mark[u] = true;
for (auto v : adj[u])
if (mark[v] && h[v] < h[u] - 1 && (!~mx || h[v] > h[mx])) mx = v;
if (~mx && h[u] - h[mx] + 1 < n && d[mx] % 3 > 1) {
for (; u ^ p[mx]; u = p[u]) good[u] = true;
return true;
}
for (auto v : adj[u])
if (!mark[v]) {
h[v] = h[p[v] = u] + 1;
if (dfs1(v)) return true;
}
return false;
}
void dfs2(int u) {
mark[u] = true;
for (auto v : adj[u])
if (!mark[v]) dfs2(v);
}
inline bool have_3k_vertex() {
for (int u = 0; u < n; u++)
if (d[u] % 3 < 1 && n > 1) return good[u] = true;
return false;
}
inline bool have_121_path() {
if (root == n) return false;
p[root] = -1, mark[root] = true;
for (q.push(root); !q.empty(); q.pop()) {
int u = q.front();
if (u ^ root && d[u] % 3 == 1 && h[u] < n - 1) {
while (!q.empty()) q.pop();
for (; ~u; u = p[u]) good[u] = true;
return true;
}
for (auto v : adj[u])
if (!mark[v]) {
q.push(v);
mark[v] = true;
h[v] = h[p[v] = u] + 1;
}
}
return false;
}
inline bool have_2_cycle() {
p[root < n ? root : 0] = -1;
fill(mark, mark + n, false);
return dfs1(root < n ? root : 0);
}
inline bool have_122_components() {
bool flag = false;
if (root == n || d[root] < 5) return flag;
fill(mark, mark + n, flag);
mark[root] = good[root] = true;
sort(adj[root].begin(), adj[root].end(),
[](int u, int v) { return h[u] < h[v]; });
for (auto u : adj[root])
if (!mark[u] && h[u] > 1) {
int v = u;
while (p[v] ^ root) good[v = p[v]] = true;
good[u] = true, dfs2(v);
if (flag) break;
flag = true;
}
return true;
}
inline void write_output() {
vector<int> vec;
for (int u = 0; u < n; u++)
if (!good[u]) vec.push_back(u);
cout << "Yes\n" << vec.size() << endl;
for (auto u : vec) cout << ++u << ' ';
cout << endl;
}
inline void read_input() {
for (cin >> n >> m; m--;) {
int u, v;
cin >> u >> v;
d[--u]++, d[--v]++;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
inline void solve() {
while (root < n && d[root] % 3 ^ 1) root++;
if (have_3k_vertex() || have_121_path() || have_2_cycle() ||
have_122_components())
write_output();
else
cout << "No\n";
}
inline void make_empty() {
for (int u = root = 0; u < n; u++) {
d[u] = h[u] = 0, adj[u].clear();
mark[u] = good[u] = false;
}
}
inline void shayan_this_is_for_you() {
int t;
cin >> t;
while (t--) {
read_input();
solve();
make_empty();
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
shayan_this_is_for_you();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005, inf = 999999999 + 208;
int n, q, t[Maxn][2], p[Maxn][2];
bool flag[Maxn];
struct event {
int num;
bool f;
} e[Maxn];
struct info {
int c[10];
void print(const info &rhs) const {
for (int i = 0; i < 9; i++) printf("%d ", c[i] - rhs.c[i]);
printf("%d\n", c[9] - rhs.c[9]);
}
} cnt[Maxn * 10], now;
void del(int x) {
p[p[x][0]][1] = p[x][1];
p[p[x][1]][0] = p[x][0];
}
void modify(int time, int dir, int &top, int stack[], int l, int r) {
if (l > r) swap(l, r);
while (top && l <= stack[top] && stack[top] <= r) t[stack[top--]][dir] = time;
}
void run(int s) {
static int time = 0, stack[2][Maxn], top[2];
int cur = s, dir = 1;
top[0] = top[1] = 0;
while (cur >= s && cur <= n) {
if (e[cur].f) {
dir = e[cur].num;
if (p[cur][dir] && e[p[cur][dir]].f) del(cur);
} else {
++now.c[e[cur].num--];
if (e[cur].num < 0) del(cur);
}
cnt[++time] = now;
if (!flag[cur]) {
flag[cur] = true;
stack[0][++top[0]] = cur;
stack[1][++top[1]] = cur;
}
modify(time, dir, top[dir], stack[dir], cur, p[cur][dir] + (dir ? -1 : 1));
cur = p[cur][dir];
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
char ch = getchar();
while (ch != '<' && ch != '>' && !isdigit(ch)) ch = getchar();
if (isdigit(ch))
e[i].num = ch - 48;
else
e[i].num = ch == '>', e[i].f = true;
p[i][0] = i - 1;
p[i][1] = i + 1;
t[i][0] = t[i][1] = inf;
}
for (int i = 1; i <= n; i++)
if (!flag[i]) run(i);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
cnt[min(t[r][1], t[l][0])].print(cnt[min(t[l][1], t[l][0]) - 1]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[100005], x, i;
int minValue = 1000000001;
int first, diff = 100005;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
a[i] = x;
minValue = min(minValue, x);
}
for (i = 0; i < n; i++) {
if (a[i] == minValue) {
first = i;
break;
}
}
for (i = 0; i < n; i++) {
if (diff == 1) break;
if (first != i && a[i] == minValue) {
diff = min((i - first), diff);
first = i;
}
}
printf("%d\n", diff);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[1000005], bo[10000005], sum, ans;
set<long long> s;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
++bo[a[i]];
s.insert(a[i]);
sum += a[i];
}
if (sum < k) {
puts("-1");
return 0;
}
if (n >= k) {
while (n > k) {
++k;
--bo[*(s.begin())];
if (!bo[*(s.begin())]) s.erase(s.begin());
}
ans = *(s.begin());
}
do {
long long j = *(--s.end());
if (j <= ans * 2) break;
if (!bo[j >> 1]) s.insert(j >> 1);
if (!bo[(j + 1) >> 1]) s.insert((j + 1) >> 1);
bo[(j + 1) >> 1] += bo[j];
bo[j >> 1] += bo[j];
s.erase(j);
n += bo[j];
if (n >= k) {
long long m = n;
set<long long>::iterator it = s.begin();
while (m - bo[*(it)] >= k) m -= bo[*(it)], ++it;
if (*(it) > ans) ans = *(it);
}
} while (*(s.begin()) != 1 || s.size() != 1);
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fastInOut();
const int N = 1e7 + 5;
long long sqrs[N];
int main() {
fastInOut();
int n;
cin >> n;
unordered_set<long long> exists;
for (long long i = 1; i * i < 1e14; ++i) sqrs[i] = i * i;
vector<long long> ans;
long long sum = 0;
int nxt = 1;
for (int i = 0; i < (n >> 1); ++i) {
long long xi;
cin >> xi;
while (sqrs[nxt]) {
long long tgt = sqrs[nxt++];
if (tgt < sum + xi) continue;
long long rem = tgt - sum - xi;
if (!binary_search(sqrs + 1, sqrs + (int)1e7, sum + rem)) continue;
if (rem < 1 || rem > (long long)1e13) continue;
ans.push_back(rem);
ans.push_back(xi);
sum += rem + xi;
break;
}
}
if ((int)ans.size() < n) {
cout << "No\n";
return 0;
}
cout << "Yes\n";
for (long long i : ans) cout << i << ' ';
cout << '\n';
return 0;
}
void fastInOut() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[101];
int b[101];
int pos = 0;
int ans = 0;
int c[101];
int ck(int pos, int l, int r) {
if (!l && !r) return 1;
if (pos == -1) return 1;
int rl = r ? b[pos] : 9;
int ll = l ? a[pos] : 0;
;
for (int i = ll; i <= rl; i++) {
int f = 0;
if (c[i]) {
c[i]--;
if (ck(pos - 1, l && i == a[pos], r && i == b[pos])) f = 1;
c[i]++;
if (f == 1) return 1;
}
}
return 0;
}
void dfs(int k, int tot) {
if (k == 9) {
c[k] = tot;
if (ck(pos - 1, 1, 1)) ans++;
return;
}
for (int i = 0; i <= tot; i++) {
c[k] = i;
dfs(k + 1, tot - i);
}
}
int main() {
long long l, r;
scanf("%I64d%I64d", &l, &r);
while (l) {
a[pos] = l % 10;
l /= 10;
pos++;
}
pos = 0;
while (r) {
b[pos] = r % 10;
r /= 10;
pos++;
}
dfs(0, pos);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1001;
long long int n, m, k;
vector<pair<long long int, long long int> > adj[N];
vector<long long int> func(long long int x) {
vector<long long int> dis(n + 1, INT_MAX);
if (x == 0) {
return dis;
}
vector<int> vis(n + 1, 0);
set<pair<long long int, long long int> > s;
s.insert(make_pair(0, x));
dis[x] = 0;
while (!s.empty()) {
long long int v = (*s.begin()).second;
s.erase(s.begin());
if (vis[v]) {
continue;
}
vis[v] = 1;
for (auto u : adj[v]) {
if (dis[u.first] > dis[v] + u.second) {
dis[u.first] = dis[v] + u.second;
s.insert(make_pair(dis[u.first], u.first));
}
}
}
return dis;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
vector<pair<pair<long long int, long long int>, long long int> > edges;
for (long long int i = 0; i < m; ++i) {
long long int a, b, w;
cin >> a >> b >> w;
adj[a].push_back(make_pair(b, w));
adj[b].push_back(make_pair(a, w));
edges.push_back(make_pair(make_pair(a, b), w));
}
vector<pair<long long int, long long int> > queries(k);
for (long long int i = 0; i < k; ++i) {
cin >> queries[i].first >> queries[i].second;
}
vector<vector<long long int> > dis;
for (long long int i = 0; i <= n; ++i) {
dis.push_back(func(i));
}
long long int ans = 0;
for (long long int i = 0; i < k; ++i) {
ans += dis[queries[i].first][queries[i].second];
}
for (long long int i = 0; i < m; ++i) {
long long int a = edges[i].first.first;
long long int b = edges[i].first.second;
long long int w = edges[i].second;
long long int cost = 0;
for (long long int j = 0; j < k; ++j) {
long long int x = queries[j].first, y = queries[j].second;
long long int price = dis[x][y];
if (dis[x][a] < dis[x][b] && dis[y][a] > dis[y][b]) {
price = min(price, dis[x][a] + dis[b][y]);
} else if (dis[x][b] < dis[x][a] && dis[y][a] < dis[y][b]) {
price = min(price, dis[x][b] + dis[y][a]);
}
cost += price;
}
ans = min(ans, cost);
}
cout << ans;
return (0);
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
int x;
const double pi = acos(-1.0);
const int mod = 1000000007;
const int maxn = 2000010;
int t = 0;
int n;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
vector<bool> c(60, false);
map<int, int> m;
void slove() {
int n, x, y, mo = 0, mi = INT_MAX;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (y < mi) mi = y;
mo += (x * mi);
}
cout << mo << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
;
if (t == 0) {
slove();
} else {
while (t--) {
slove();
}
};
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int ll_max(long long int a, long long int b, long long int c) {
return max(a, max(b, c));
}
int int_max(int a, int b, int c) { return max(a, max(b, c)); }
long long int ll_min(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
int int_min(int a, int b, int c) { return min(a, min(b, c)); }
long long int max(int a, long long int b) { return max((long long int)a, b); }
long long int min(int a, long long int b) { return min((long long int)a, b); }
long long int min(long long int a, int b) { return min(a, (long long int)b); }
long long int max(long long int a, int b) { return max(a, (long long int)b); }
long long int dx[] = {0, 0, 1, -1};
long long int dy[] = {1, -1, 0, 0};
long long int power(long long int x, long long int y, long long int m) {
if (y == 0) return 1;
long long int a = power(x, y / 2, m);
if (y % 2) {
return (a * ((a * x) % m)) % m;
} else {
return (a * a) % m;
}
}
long long int mod_inverse(long long int x, long long int m) {
return power(x, m - 2, m);
}
long long int fact(long long int n, long long int m) {
if (n <= 1) return 1;
return (fact(n - 1, m) * n) % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
if (r > n) return 0;
long long int n1 = 1, d1 = 1, d2 = 1;
n1 = fact(n, m);
d1 = fact(r, m);
d2 = fact(n - r, m);
long long int ans = mod_inverse((d1 * d2) % m, m);
ans = (ans * n1) % m;
return ans;
}
int gcd(int a, int b) {
if (a < b) return gcd(b, a);
if (a % b == 0) return b;
return gcd(b, a % b);
}
int ispal(string s) {
int len = s.size();
int flag = 1;
for (int i = 0; i < len; ++i) {
if (s[i] != s[len - i - 1]) {
flag = 0;
break;
}
}
return flag;
}
long long int sroot(long long int n, long long int low = 1,
long long int high = 1e9 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid;
if (a > n)
return sroot(n, low, mid - 1);
else
return sroot(n, mid, high);
}
long long int croot(long long int n, long long int low = 1,
long long int high = 1e6 + 1) {
if (low == high) return low;
if (low == high - 1) {
if (high * high * high <= n)
return high;
else
return low;
}
long long int mid = (low + high) / 2;
long long int a = mid * mid * mid;
if (a > n)
return croot(n, low, mid - 1);
else
return croot(n, mid, high);
}
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, k;
cin >> n >> k;
long long int x[n];
for (long long int i = 0; i < n; i++) cin >> x[i];
long long int gain;
cin >> gain;
long long int cost[n];
for (long long int i = 0; i < n; i++) cin >> cost[i];
long long int ans = 0, y = k;
long long int max1 = -1, ind = 0;
for (long long int i = 0; i < n; i++) max1 = max(max1, x[i]);
for (long long int i = 0; i < n; i++) {
if (x[i] == max1) {
ind = i;
break;
}
}
long long int drink = 0, a = k;
vector<vector<long long int>> v(n + 5);
ans = 0;
for (long long int i = 0; i < n; i++) {
v[i].push_back(cost[i]);
if (k < x[i]) {
long long int drink = ceil((x[i] - k) / (gain * 1.0));
if (drink > v[i].size()) {
ans = -1;
break;
} else {
sort(v[i].begin(), v[i].end());
for (long long int j = 0; j < drink; j++) ans += v[i][j];
k += drink * gain;
for (long long int j = drink; j < v[i].size(); j++)
v[i + 1].push_back(v[i][j]);
}
} else {
v[i + 1] = v[i];
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[5];
int main() {
int n, i, x, sum = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
if (a[2] % 2 == 0) {
sum += a[2] / 2;
a[2] = 0;
} else {
sum += a[2] / 2;
a[2] = 1;
a[1] -= 2;
sum++;
}
if (a[3] > a[1]) {
sum += a[3];
a[3] = 0;
a[1] = 0;
} else {
sum += a[3];
a[1] = a[1] - a[3];
}
if (a[1] > 0) {
if (a[1] % 4 == 0)
sum += a[1] / 4;
else
sum += a[1] / 4 + 1;
}
cout << sum + a[4] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int vis[1000000];
int n[1000000];
int main() {
int cnt = 0;
int l;
cin >> l;
for (int i = 0; i < l; i++) {
cin >> n[i];
}
sort(n, n + l);
for (int i = 0; i < l; i++) {
int x = n[i] - 1;
if (x < 1) x = 1;
int y = n[i];
int z = n[i] + 1;
if (!vis[x]) {
vis[x] = 1;
++cnt;
} else if (!vis[y]) {
vis[y] = 1;
++cnt;
} else if (!vis[z]) {
vis[z] = 1;
++cnt;
}
}
cout << cnt << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 1 << 20;
ll eval(vector<ll> coefs, ll x) {
int n = coefs.size();
ll sum = 0, pw = 1, cur;
for (int i = 0; i < n; i++) {
if (i && __builtin_mul_overflow(pw, x, &pw)) return -1;
if (__builtin_mul_overflow(pw, coefs[i], &cur)) return -1;
if (__builtin_add_overflow(cur, sum, &sum)) return -1;
}
return sum;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
ll t, a, b;
cin >> t >> a >> b;
if ((t == a) && (a != b)) return cout << "0\n", 0;
if (a == 1 && b == 1 && t == 1) return cout << "inf\n", 0;
int ans = 0;
for (ll tk = 1, ak = 1; tk <= a && ak <= b;) {
ll C = a / tk;
if (C * tk == a && C * ak == b) ans++;
if (__builtin_mul_overflow(ak, a, &ak)) break;
if (__builtin_mul_overflow(tk, t, &tk)) break;
}
if (a > 1) {
vector<ll> coefs;
for (ll tb = b; tb; tb /= a) coefs.push_back(tb % a);
int nz = 0;
for (auto i : coefs) nz += !!i;
;
if (nz > 1) ans += eval(coefs, t) == a && eval(coefs, a) == b;
}
cout << ans << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, ans = 0;
string d;
cin >> c;
cin >> d;
for (int i = 0; i < c - 1; i++) {
int x = 0, y = 0;
for (int j = i; j < c; j++) {
switch (d[j]) {
case 'R':
x++;
break;
case 'L':
x--;
break;
case 'U':
y++;
break;
case 'D':
y--;
break;
default:
break;
}
if (x == 0 && y == 0) ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, x;
cin >> n >> x;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
if (a[i] > b[i]) {
swap(a[i], b[i]);
}
}
int cnt[1001];
for (int i = 0; i < 1001; i++) {
cnt[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = a[i]; j <= b[i]; j++) {
cnt[j]++;
}
}
bool ans = false;
int hld;
int small = 1e5;
for (int i = 0; i < 1001; i++) {
if (cnt[i] == n) {
ans = true;
hld = i;
small = min(small, abs(x - hld));
}
}
if (ans) {
cout << small;
} else {
cout << -1;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
string s, t;
cin >> s >> t;
bool flag = true;
set<char> a, b, c;
for (auto &val : s) {
a.insert(val);
c.insert(val);
}
for (auto &val : t) {
b.insert(val);
c.insert(val);
}
if (c.size() == a.size() + b.size()) {
flag = false;
}
if (flag) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int len = 0, i;
int count1 = 0, count2 = 0;
char ch[101];
scanf("%s", ch);
len = strlen(ch);
for (i = 0; i < len; i++) {
if (ch[i] >= 65 && ch[i] <= 90) count1++;
}
count2 = len - count1;
if (count1 > count2) {
for (i = 0; i < len; i++) {
if (ch[i] >= 97 && ch[i] <= 122) ch[i] = ch[i] - 32;
}
} else {
for (i = 0; i < len; i++) {
if (ch[i] >= 65 && ch[i] <= 90) ch[i] = ch[i] + 32;
}
}
printf("%s", ch);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 5, Q = 5e3 + 5, LG = 18;
int n, q, A[LG][N], L[Q], R[Q], M[Q], W[Q];
double P[Q], DP[Q][Q];
stack<int> S;
vector<int> G[Q];
int RMQ(int l, int r) {
int x = log2(r - l);
return max(A[x][l], A[x][r - (1 << x)]);
}
void DFS(int v) {
for (int i = 0; i < Q; i++) DP[v][i] = 1;
for (int u : G[v]) DFS(u);
for (int u : G[v])
for (int i = 0; i < Q; i++) DP[v][i] *= DP[u][min(Q - 1, M[v] - M[u] + i)];
for (int i = Q - 1; i >= 0; i--) {
DP[v][i] *= 1 - P[v];
if (i) DP[v][i] += P[v] * DP[v][i - 1];
}
return;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> A[0][i];
for (int pw = 1; pw < LG; pw++)
for (int i = 0; i < n; i++)
A[pw][i] = max(A[pw - 1][i], A[pw - 1][i + (1 << (pw - 1))]);
L[0] = 0, R[0] = n, M[0] = RMQ(0, n), P[0] = 0, S.push(0);
for (int i = 1; i < q + 1; i++)
cin >> L[i] >> R[i] >> P[i], M[i] = RMQ(--L[i], R[i]), W[i] = i;
sort(W + 1, W + q + 1, [&](int i, int j) {
return make_pair(L[i], -R[i]) < make_pair(L[j], -R[j]);
});
for (int i = 1; i < q + 1; i++) {
while (R[S.top()] <= L[W[i]]) S.pop();
G[S.top()].push_back(W[i]);
S.push(W[i]);
}
DFS(0);
double ans = DP[0][0] * M[0];
for (int i = 1; i < Q; i++) ans += (DP[0][i] - DP[0][i - 1]) * (M[0] + i);
cout << fixed << setprecision(6) << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long bal = 0, cnt1 = 0, cnt2 = 0, ans = 0;
for (long long i = 0; i < n; ++i) {
long long x;
cin >> x;
if (bal % 2 == 0)
cnt1++;
else
cnt2++;
if (x < 0) bal++;
if (bal % 2 == 0)
ans += cnt1;
else
ans += cnt2;
}
cout << (n * (n + 1)) / 2 - ans << " " << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const long long mod = 1000000007;
const double eps = 1e-9;
const double pi = 3.1415926535897932384626;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int n, m;
char brd[110][110];
bool check(int i, int j, char c) {
if ((i == 0 || brd[i - 1][j] != c) && (j == 0 || brd[i][j - 1] != c) &&
brd[i][j + 1] != c) {
brd[i][j] = c;
return 1;
}
if (i != 0 && brd[i - 1][j] == c) return 0;
if (brd[i][j + 1] == c) return 0;
int posj = j - 1;
while (posj >= 0 && brd[i][posj] == brd[i][j - 1]) --posj;
int len = j - posj;
++posj;
if (i + len > n || posj + len > m) return 0;
for (int p = i; p < i + len; p++)
if (brd[p][j + 1] == c) return 0;
if (posj != 0 && brd[i + len - 1][posj - 1] == c) return 0;
for (int p = i; p < i + len; p++) brd[p][j] = c;
for (int p = posj; p < posj + len; p++) brd[i + len - 1][p] = c;
return 1;
}
int main() {
scanf("%d%d", &n, &m);
bool tr = 1;
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)m; j++) {
if (brd[i][j]) {
tr = 0;
continue;
}
if (tr == 0) {
for (char c = 'A';; c++) {
if ((i == 0 || brd[i - 1][j] != c) &&
(j == 0 || brd[i][j - 1] != c) && brd[i][j + 1] != c) {
brd[i][j] = c;
break;
}
}
} else
for (char c = 'A';; c++)
if (check(i, j, c)) break;
tr = 1;
}
for (int i = 0; i < (int)n; i++) puts(brd[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int temp;
long long int sum[n];
for (int i = 0; i < n; i++) {
cin >> temp;
if (i == 0) {
sum[i] = temp;
} else {
sum[i] = sum[i - 1] + temp;
}
}
long long int t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
a--;
b--;
if (a == 0) {
cout << ((sum[b]) / 10) << "\n";
} else {
a--;
cout << ((sum[b] - sum[a]) / 10) << "\n";
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void sll(long long &x) {
register char c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
void wll(long long a) {
if (a < 0) {
putchar('-');
a = -a;
}
char snum[100];
int i = 0;
do {
snum[i++] = a % 10 + 48;
a = a / 10;
} while (a != 0);
--i;
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
void wi(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
char snum[100];
int i = 0;
do {
snum[i++] = a % 10 + 48;
a = a / 10;
} while (a != 0);
--i;
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
void wl(long a) {
if (a < 0) {
putchar('-');
a = -a;
}
char snum[100];
int i = 0;
do {
snum[i++] = a % 10 + 48;
a = a / 10;
} while (a != 0);
--i;
while (i >= 0) putchar(snum[i--]);
putchar('\n');
}
void sl(long &x) {
register char c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
void si(int &x) {
register char c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
long long power(long long a, long long b, long long mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % mod;
a = a * a % mod;
b >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) {
while (b) b ^= a ^= b ^= a %= b;
return a;
}
int main() {
long long t, i, j, k, l;
long long a, b, c, d;
sll(a);
sll(b);
sll(c);
sll(l);
t = (l + 1) * (l + 2) * (l + 3) / 6;
long long ans = 0;
for (i = 0; i <= l; i++) {
long long x = min(l - i, i + a - b - c);
if (x >= 0) {
x = ((x + 1) * (x + 2)) >> 1;
ans += x;
}
x = min(l - i, i + c - b - a);
if (x >= 0) {
x = ((x + 1) * (x + 2)) >> 1;
ans += x;
}
x = min(l - i, i + b - c - a);
if (x >= 0) {
x = ((x + 1) * (x + 2)) >> 1;
ans += x;
}
}
wll(t - ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char eggs[] = {'R', 'O', 'Y', 'G', 'B', 'I', 'V'};
char spec[] = {'G', 'B', 'I', 'V'};
int n;
cin >> n;
if (n == 7) {
for (int i = int(0); i <= int(n - 1); i++) {
cout << eggs[i % 7];
}
} else {
for (int i = int(0); i <= int(n - 1); i++) {
if (i == 4) {
cout << 'R';
} else if (i > 4) {
cout << spec[(i) % 4];
} else {
cout << eggs[i % 7];
}
}
}
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct gameTheoryGraph {
struct Edge {
int id;
int dest;
long long weight;
Edge(int _dest = -1, long long _weight = 1, int _id = 0) {
dest = _dest;
weight = _weight;
id = _id;
}
bool operator<(const Edge& other) const { return dest < other.dest; }
};
int n;
vector<vector<Edge>> adj;
vector<int> mex, topologicalOrder;
gameTheoryGraph(int nodes = 0) {
n = nodes;
adj.resize(n + 1);
}
void addEdgeDirected(int u, int v, long long w = 1) {
adj[u].push_back(Edge(v, w));
}
void getMex() {
mex = vector<int>(n + 1, -1);
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 0) mex[i] = 0;
}
topoSort();
vector<int> neighbourMex(n, 0);
reverse(topologicalOrder.begin(), topologicalOrder.end());
for (auto cur : topologicalOrder) {
if (mex[cur] == -1) {
for (auto it : adj[cur]) {
neighbourMex[mex[it.dest]] = 1;
}
mex[cur] = 0;
while (neighbourMex[mex[cur]] == 1) mex[cur]++;
for (auto it : adj[cur]) {
neighbourMex[it.dest] = 0;
}
}
}
}
void topoSort() {
vector<int> ins(n + 1, 0);
topologicalOrder.clear();
for (int i = (1); i <= (n); ++i)
for (auto it : adj[i]) ++ins[it.dest];
deque<int> q;
for (int i = (1); i <= (n); ++i)
if (ins[i] == 0) q.push_back(i);
while (!q.empty()) {
int v = q.front();
q.pop_front();
for (auto it : adj[v])
if ((--ins[it.dest]) == 0) topologicalOrder.push_back(it.dest);
topologicalOrder.push_back(v);
}
topologicalOrder = (int((topologicalOrder).size()) == n) ? topologicalOrder
: vector<int>();
}
};
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
int n;
cin >> n;
vector<vector<long long>> a(n);
long long total = 0;
for (int i = 0; i < n; i++) {
int si;
cin >> si;
a[i].resize(si);
for (int j = 0; j < si; j++) {
cin >> a[i][j];
total += a[i][j];
}
}
long long player1 = 0;
vector<long long> rem;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (a[i].size() / 2); j++) {
player1 += a[i][j];
}
if (a[i].size() % 2 == 1) {
rem.push_back(a[i][a[i].size() / 2]);
}
}
sort(rem.begin(), rem.end());
reverse(rem.begin(), rem.end());
for (int i = 0; i < rem.size(); i += 2) {
player1 += rem[i];
}
cout << player1 << " " << total - player1 << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 2;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int l = n, r = -1, v = m, d = -1;
int c = 0;
vector<vector<char> > a(n, vector<char>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 'B') {
l = min(l, i);
r = max(r, i);
v = min(v, j);
d = max(d, j);
c++;
}
}
}
if (c == 0) {
cout << 1;
return 0;
}
int dl = max(r - l + 1, d - v + 1);
if (n < dl || m < dl) {
cout << -1;
return 0;
} else {
cout << dl * dl - c;
return 0;
}
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.