solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, t[12000], tl[3010][3010], tz[3010][3010], tr[3010][3010],
z[3010][3010], ini[12000], fim[12000], a[3010];
long long r;
vector<int> mst[12000];
char c;
void build_mst(int pos, int lo, int hi) {
ini[pos] = lo;
fim[pos] = hi;
mst[pos].clear();
if (lo == hi) {
mst[pos].push_back(a[lo]);
t[pos] = 1;
return;
}
build_mst(2 * pos, lo, (lo + hi) / 2);
build_mst(2 * pos + 1, (lo + hi) / 2 + 1, hi);
t[pos] = t[2 * pos] + t[2 * pos + 1];
int p1 = 0, p2 = 0;
for (int i = 0; i < t[pos]; i++) {
if (p1 < t[2 * pos]) {
if (p2 < t[2 * pos + 1] && mst[2 * pos + 1][p2] < mst[2 * pos][p1]) {
mst[pos].push_back(mst[2 * pos + 1][p2]);
p2++;
} else {
mst[pos].push_back(mst[2 * pos][p1]);
p1++;
}
} else {
mst[pos].push_back(mst[2 * pos + 1][p2]);
p2++;
}
}
return;
}
long long grtr(int pos, int val, int lo, int hi) {
if (ini[pos] > hi || fim[pos] < lo) return 0;
if (ini[pos] >= lo && fim[pos] <= hi) {
if (mst[pos][t[pos] - 1] <= val) return 0;
int mi = 0, ma = t[pos] - 1;
long long mid = (ma + mi) / 2;
while (mi != ma) {
if (mst[pos][mid] > val)
ma = mid;
else
mi = mid + 1;
mid = (ma + mi) / 2;
}
return t[pos] - mid;
}
return grtr(2 * pos, val, lo, hi) + grtr(2 * pos + 1, val, lo, hi);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf(" %c", &c);
if (c == 'z') {
tl[i][j] = 1 + tl[i][j - 1];
tz[i][j] = 1 + tz[i - 1][j + 1];
}
}
}
for (int i = 1; i <= n; i++)
for (int j = m; j > 0; j--)
if (tl[i][j]) tr[i][j] = 1 + tr[i][j + 1];
for (int i = 1; i <= m; i++) {
for (int j = 1; i - j >= 0 && j <= n; j++) {
a[j] = 0;
if (tl[j][i - j + 1]) a[j] = tl[j][i - j + 1] + j;
}
build_mst(1, 1, min(i, n));
for (int j = 1; i - j >= 0 && j <= n; j++)
r += grtr(1, j, j - min(tr[j][i - j + 1], tz[j][i - j + 1]) + 1, j);
}
for (int i = 2; i <= n; i++) {
for (int j = 1; i + j - 1 <= n && j <= m; j++) {
a[j] = 0;
if (tl[i + j - 1][m - j + 1]) a[j] = tl[i + j - 1][m - j + 1] + j;
}
build_mst(1, 1, min(m, n - i + 1));
for (int j = 1; i + j - 1 <= n && j <= m; j++)
r += grtr(1, j,
j - min(tr[i + j - 1][m - j + 1], tz[i + j - 1][m - j + 1]) + 1,
j);
}
printf("%lld\n", r);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
inline long long UB(vector<long long> &v, long long x) {
return upper_bound(v.begin(), v.end(), x) - v.begin();
}
inline long long LB(vector<long long> &v, long long x) {
return lower_bound(v.begin(), v.end(), x) - v.begin();
}
bool uMin(long long &a, long long b) { return a > b ? (a = b, true) : false; }
bool uMax(long long &a, long long b) { return a < b ? (a = b, true) : false; }
const long long Mod = 1e9 + 6;
inline long long PowMod(long long a, long long b) {
long long res = 1;
a %= Mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % Mod;
a = a * a % Mod;
}
return res;
}
const long long MxSize = 1000006;
long long depth = 0;
string nodes[MxSize];
long long nodeHead = 1;
class StringDigitReader {
private:
char buff[MxSize];
public:
string src;
friend istream &operator>>(istream &ins, StringDigitReader &sdr) {
ins >> sdr.src;
return ins;
}
long long SkipUntil(long long startId, char skipChar) {
while (startId < src.length() && src[startId] != skipChar) startId++;
return startId;
}
long long SkipNonDigitString(long long startId) {
while (startId < src.length() && (src[startId] < '0' || src[startId] > '9'))
startId++;
return startId;
}
long long ReadInt(long long startId, char thousandChar, long long &result) {
long long cnt = 0;
while (startId < src.length() &&
(src[startId] >= '0' && src[startId] <= '9' ||
src[startId] == thousandChar)) {
buff[cnt++] = src[startId++];
}
result = 0;
for (size_t i = 0; i < cnt; i++)
if (buff[i] != thousandChar) {
result = result * 10 + buff[i] - '0';
}
return startId;
}
long long ReadDouble(long long startId, char thousandChar, double &result) {
long long cnt = 0;
while (startId < src.length() &&
(src[startId] == '.' || src[startId] == thousandChar ||
(src[startId] >= '0' && src[startId] <= '9'))) {
buff[cnt++] = src[startId++];
}
result = 0;
if (cnt >= 4 && buff[cnt - 3] == '.') {
double factor = 0.1;
for (size_t i = 0; i < cnt; i++) {
if (i < cnt - 3 && buff[i] == thousandChar) continue;
if (i < cnt - 3)
result = result * 10 + buff[i] - '0';
else if (i > cnt - 3) {
result += (buff[i] - '0') * factor;
factor /= 10;
}
}
} else {
for (size_t i = 0; i < cnt; i++) {
if (buff[i] == thousandChar) continue;
result = result * 10 + buff[i] - '0';
}
}
return startId;
}
};
StringDigitReader sr;
void onSideEnumerating(long long x, long long y, long long weight);
void BeforeGroupDetection_inDFS(long long x);
bool CanAddPointToGroup_inDFS(long long x);
void AddingNewPointToGroup_inDFS(long long x);
void AfterGroupDetected_inDFS(long long x);
void BeforeProcess_inDP(long long x);
void EnteringNode_inDP(long long x);
long long LeavingNode_inDP(long long x);
void HandleSubNodeResult_inDP(long long x, long long y, long long returnValue);
void AfterProcess_inDP(long long x);
void BeforeProcess_inBFS(long long x);
void VisitingNode_inBFS(long long x, long long lv);
void AfterProcess_inBFS(long long x);
class VectorArrayBasedGraphics {
private:
long long dFrom, dTo;
vector<pair<long long, long long>> p[MxSize];
public:
VectorArrayBasedGraphics() {
dFrom = 0;
dTo = 0;
}
~VectorArrayBasedGraphics() {}
void Initialize(long long dataIdFrom, long long dataIdTo) {
dFrom = dataIdFrom;
dTo = dataIdTo;
for (long long i = dataIdFrom; i <= dataIdTo; i++) {
p[i].clear();
}
}
void AddSide(long long v1, long long v2, long long weight = 1,
bool isTwoWay = true) {
p[v1].push_back(make_pair(v2, weight));
if (isTwoWay) p[v2].push_back(make_pair(v1, weight));
}
template <typename T2>
void CombineSamePropertyNodes(T2 propertyArray[], long long beginID,
long long endID) {
for (long long i = beginID; i <= endID; i++) {
for (vector<pair<long long, long long>>::iterator it = p[i].begin();
it != p[i].end();) {
if (propertyArray[i] == propertyArray[*it]) {
long long itv = it->first;
it = p[i].erase(it);
for (vector<pair<long long, long long>>::iterator tit =
p[itv].begin();
tit != p[itv].end(); tit++) {
long long titv = tit->first;
if (i == titv) continue;
long long offset = it - p[i].begin();
p[i].push_back(*tit);
it = p[i].begin() + offset;
for (vector<pair<long long, long long>>::iterator soManyIt =
p[titv].begin();
soManyIt != p[titv].end(); soManyIt++) {
if (soManyIt->first == itv) {
p[titv].erase(soManyIt);
break;
}
}
p[titv].push_back(make_pair(i, 0));
}
p[itv].clear();
} else {
it++;
}
}
}
}
private:
bool used[MxSize];
private:
queue<pair<long long, long long>> que;
public:
void Start_BFS_Process(long long root) {
memset(used + dFrom, false, sizeof(bool) * (dTo - dFrom + 1));
BeforeProcess_inBFS(root);
bfs(root);
AfterProcess_inBFS(root);
}
void bfs(long long node) {
long long lv = 0;
que.push(make_pair(node, lv));
while (!que.empty()) {
node = que.front().first;
lv = que.front().second;
VisitingNode_inBFS(node, lv);
long long tNode;
for (long long i = 0; i < p[node].size(); i++) {
tNode = p[node][i].first;
if (used[tNode]) continue;
used[tNode] = true;
que.push(make_pair(tNode, lv + 1));
}
que.pop();
}
}
};
VectorArrayBasedGraphics g;
long long cLv;
void BeforeProcess_inBFS(long long node) { cLv = 0; }
void VisitingNode_inBFS(long long node, long long lv) {
if (lv != cLv) cout << endl;
cLv = lv;
if (node != 0) cout << nodes[node] << ' ';
}
void AfterProcess_inBFS(long long node) {}
void AppendNode(long long &id, long long father, long long dep) {
dep++;
if (dep > depth) depth = dep;
long long curr = nodeHead++;
long long newID;
newID = sr.SkipUntil(id, ',');
nodes[curr] = sr.src.substr(id, newID - id);
g.AddSide(father, curr);
id = newID + 1;
long long x;
newID = sr.ReadInt(id, '_', x);
id = newID + 1;
for (long long i = 0; i < x; i++) {
AppendNode(id, curr, dep);
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> sr;
g.Initialize(0, MxSize - 2);
long long id = 0;
while (id < sr.src.length()) AppendNode(id, 0, 0);
cout << depth;
g.Start_BFS_Process(0);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n, 0);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> r_seq, t_seq;
for (int i = 0; i < m; ++i) {
int t, r;
cin >> t >> r;
while (!r_seq.empty() && r >= r_seq.back()) {
r_seq.pop_back();
t_seq.pop_back();
}
r_seq.push_back(r);
t_seq.push_back(t);
}
r_seq.push_back(0);
vector<int> b(a.begin(), a.begin() + r_seq[0]);
sort(b.begin(), b.end());
int left = 0, right = b.size() - 1;
for (int i = 1; i < r_seq.size(); ++i) {
for (int j = r_seq[i - 1]; j > r_seq[i]; --j) {
a[j - 1] = (t_seq[i - 1] == 1) ? b[right--] : b[left++];
}
}
for (int i = 0; i < a.size(); ++i) {
cout << a[i] << " ";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, M, mins, maks, K, F, i;
int main() {
cin >> N >> M;
mins = 1;
maks = 1000;
for (i = 0; i < M; i++) {
cin >> K >> F;
mins = max(mins, (K - 1) / F + 1);
if (F > 1) {
maks = min(maks, (K - 1) / (F - 1));
}
}
mins = (N - 1) / mins + 1;
if (maks == 1) {
maks = mins;
} else {
maks = (N - 1) / (maks) + 1;
}
if (mins != maks) {
cout << -1 << '\n';
} else {
cout << mins << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a, second[1111111], b[1111111], sum, c[1111], ans, n;
pair<long long, long long> p[111111];
int main() {
vector<long long> v;
cin >> a >> n;
for (int i = 1; i <= a; i++) {
cin >> p[i].first;
p[i].second = i;
}
sort(p + 1, p + a + 1);
for (int i = 1; i <= a; i++) {
sum += p[i].first;
if (sum <= n) {
v.push_back(p[i].second);
}
}
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
long long dp[N][10];
char s[N];
int main() {
int n;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i < 10; i++) dp[1][i] = 1;
for (int i = 2; i <= n; i++) {
int now = s[i] - '0';
for (int j = 0; j <= 9; j++) {
if ((now + j) % 2 == 0)
dp[i][(now + j) / 2] += dp[i - 1][j];
else {
dp[i][(now + j) / 2] += dp[i - 1][j];
dp[i][(now + j + 1) / 2] += dp[i - 1][j];
}
}
}
int flag = 1;
for (int i = 2; i <= n; i++) {
int now = s[i] - '0', last = s[i - 1] - '0';
if ((last + now) / 2 == now || (last + now + 1) / 2 == now)
;
else {
flag = 0;
break;
}
}
long long ans = 0;
for (int j = 0; j < 10; j++) ans += dp[n][j];
printf("%lld\n", ans - flag);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const long long INF = 1e18;
const long long MOD = 10007;
long long G[MAXN], L[MAXN];
long long N;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = (0); i < (N); i++) {
cin >> G[i];
L[i] = G[i];
}
sort(G, G + N);
reverse(G, G + N);
sort(L, L + N);
long long ans = 0;
for (int i = (0); i < (N); i++) ans += G[i] * L[i], ans %= MOD;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
char s[200000];
int i, j, n, len, num[30];
int main() {
scanf("%s", s);
len = strlen(s);
for (i = 0; i < len; i++) num[s[i] - 'a']++;
for (i = 0; i < len; i++) {
bool flag = true;
for (j = s[i] + 1; j <= 'z'; j++)
if (num[j - 'a'] != 0) flag = false;
num[s[i] - 'a']--;
if (flag) printf("%c", s[i]);
}
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int binomialCoeff(long long int n, long long int k) {
long long int res = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
vector<long long int> primes;
void Sieve(int n) {
vector<bool> prime(n + 1, true);
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
const int Nmax = 1e6 + 6;
long long int modInverse(long long int a, long long int m = 998244353) {
long long int m0 = m;
long long int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long int q = a / m;
long long int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long int row[Nmax];
long long int col[Nmax];
long long int rr[Nmax];
long long int cc[Nmax];
long long int ans;
long long int val[Nmax] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int mod = 998244353;
int n, m;
cin >> n >> m;
long long int arr[n + 1][m + 1];
vector<tuple<long long int, long long int, long long int> > v;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> arr[i][j];
v.push_back(make_tuple(arr[i][j], i, j));
}
}
sort(v.begin(), v.end());
pair<long long int, long long int> end;
cin >> end.first >> end.second;
long long int q = 0;
vector<long long int> v2;
for (int i = 0; i < v.size(); i++) {
long long int a, r, c;
tie(a, r, c) = v[i];
if (i == 0) {
v2.push_back(a);
val[i] = 0;
col[i] = c;
row[i] = r;
cc[i] = c * c;
rr[i] = r * r;
if (end.first == r && end.second == c) {
ans = 0;
break;
}
continue;
}
long long int q = lower_bound(v2.begin(), v2.end(), a) - v2.begin();
v2.push_back(a);
if (q == 0) {
val[i] = (val[i] + val[i - 1]) % mod;
row[i] = row[i - 1] + r;
row[i] %= mod;
col[i] = col[i - 1] + c;
col[i] %= mod;
rr[i] = rr[i - 1] + r * r;
rr[i] %= mod;
cc[i] = cc[i - 1] + c * c;
cc[i] %= mod;
if (end.first == r && end.second == c) {
ans = 0;
break;
}
continue;
}
long long int inv = modInverse(q);
long long int res = (r * r % mod + c * c % mod) % mod;
res += val[q - 1] * (inv) % mod;
res %= mod;
res += cc[q - 1] * (inv) % mod + rr[q - 1] * (inv) % mod;
res %= mod;
long long int t = ((2 * (r * row[q - 1]) % mod) % mod * (inv)) % mod +
((2 * (c * col[q - 1]) % mod) % mod * (inv)) % mod;
t %= mod;
res -= t;
if (res < 0) res += mod;
if (end.first == r && end.second == c) {
ans = res;
break;
}
val[i] = (val[i - 1] + res) % mod;
col[i] = (col[i - 1] + c) % mod;
row[i] = (row[i - 1] + r) % mod;
cc[i] = (cc[i - 1] + c * c) % mod;
rr[i] = (rr[i - 1] + r * r) % mod;
}
cout << ans % mod;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
cin >> n >> x;
long long p, s = 0;
for (long long i = 0; i < n; i++) {
cin >> p;
s += p;
}
if (s + n - 1 <= x) {
x = x - (s + n - 1);
if (x == 0)
cout << "YES";
else
cout << "NO";
} else
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int ans = n;
for (int j = 1; j * j <= n; j++) {
if (n % j == 0) {
if (j <= k) {
ans = min(ans, n / j);
}
if (n / j <= k) {
ans = min(ans, j);
}
}
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct point {
int x, y;
void in() { scanf("%d%d", &x, &y); }
};
struct node {
point a, b, c, d;
void update() {
c.x = b.x;
c.y = a.y;
d.x = a.x;
d.y = b.y;
}
} rec[6];
long long cal(point a, point b) {
int x = b.x - a.x;
int y = b.y - a.y;
return (long long)x * y;
}
bool ff(point a, point b) { return b.x - a.x == b.y - a.y; }
bool xiao(point a, point b) { return a.x <= b.x && a.y <= b.y; }
bool da(point a, point b) { return a.x >= b.x && a.y >= b.y; }
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
rec[i].a.in(), rec[i].b.in();
rec[i].update();
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (!ff(rec[i].a, rec[j].b)) continue;
long long s = cal(rec[i].a, rec[j].b);
long long ss = 0;
for (k = 0; k < n; k++) ss += cal(rec[k].a, rec[k].b);
point xx = rec[i].a, yy = rec[j].b;
if (s == ss) {
for (k = 0; k < n; k++)
if (xiao(xx, rec[k].a) && xiao(xx, rec[k].b) && xiao(xx, rec[k].c) &&
xiao(xx, rec[k].d) && da(yy, rec[k].a) && da(yy, rec[k].b) &&
da(yy, rec[k].c) && da(yy, rec[k].d))
continue;
else
break;
if (k == n) {
puts("YES");
return 0;
}
}
}
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long dp[55][1010];
long long v[55][1010];
long long ke[55];
long long bin[2020][2020];
void cv(int k, int n) {
int rs = n - k;
if (rs < 0) return;
for (int i = 0; i <= rs; i++) {
v[k][n] += bin[k + rs - i][k] * dp[k][i];
v[k][n] %= mod;
}
v[k][n] *= ke[k];
v[k][n] %= mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
bin[0][0] = 1;
for (int i = 1; i <= 2000; i++) {
bin[i][0] = 1;
for (int j = 1; j <= 2000; j++) {
bin[i][j] = bin[i - 1][j - 1] + bin[i - 1][j];
bin[i][j] %= mod;
}
}
dp[0][0] = 1;
for (int t = 0; t <= 1000; t++) {
for (int j = 50; j > 0; j--) {
for (int i = 1000; i - t >= 0; i--) {
dp[j][i] += dp[j - 1][i - t];
dp[j][i] %= mod;
}
}
}
ke[0] = 1;
for (long long i = 1; i <= 50; i++) {
ke[i] = ke[i - 1] * i;
ke[i] %= mod;
}
for (int i = 1; i <= 50; i++) {
for (int j = 1; j <= 1000; j++) {
cv(i, j);
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int n, k;
cin >> n >> k;
if (k > 50)
cout << 0 << '\n';
else
cout << v[k][n] << '\n';
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i <= n; i++) {
for (int x = 0; x < n; x++) {
if (s[x] == '.') continue;
int j = x;
int num = 1;
while (j < n) {
j += i;
if (j < n && s[j] == '*')
num++;
else
break;
}
if (num >= 5) {
cout << "yes" << endl;
return 0;
}
}
}
cout << "no" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cout.tie(0);
cout.sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
cout << a[n - 1] - a[0] + 1 - a.size();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
for (int i = 1; i < s.size(); i++) {
if (s[i] == s[i - 1]) {
for (char j = 'a'; j <= 'z'; j++) {
if (s[i - 1] != j && s[i + 1] != j) {
s[i] = j;
break;
}
}
}
}
cout << s << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100100], dp[100100], l[100100];
int rec(int i) {
if (i == 0) return 0;
l[i] = min(n, i + k);
if (a[i] == 0) return min(n, i + k) - max(1, i - k) + 1;
if (dp[i]) return dp[i];
dp[i] = rec(a[i]) + min(n, i + k) - max(l[a[i]], i - k - 1);
return dp[i];
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cout << rec(i) << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
if (n < 4) {
std::cout << "NO";
return 0;
}
if (n == 4) {
std::cout << "YES\n1 * 2 = 2\n2 * 3 = 6\n6 * 4 = 24";
} else if (n == 5) {
std::cout << "YES\n4 * 5 = 20\n20 + 3 = 23\n23 + 2 = 25\n25 - 1 = 24";
} else {
std::cout << "YES\n6 * 4 = 24\n3 + 2 = 5\n5 - 5 = 0\n1 * 0 = 0\n";
for (int i = 7; i <= n; ++i) std::cout << i << " * 0 = 0\n";
std::cout << "24 + 0 = 24";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
double d = sqrt(b * b - 4 * a * c);
double x = -(b + d) / 2 / a;
double y = -(b - d) / 2 / a;
if (a < 0) {
swap(x, y);
}
cout << setprecision(9) << y << "\n" << setprecision(9) << x;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100020];
double z, s;
int n, v;
bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
return a.first * a.second * (100 - b.second) >
b.first * b.second * (100 - a.second);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d%d", &a[i].first, &a[i].second), v += a[i].first;
sort(a, a + n, cmp);
for (int i = 0; i < n; i++) {
z += s * (100 - a[i].second);
s += a[i].first * a[i].second;
}
printf("%.9f", z / 10000 + v);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
const int MAXB = 20;
int n, m, k, c;
int fa[MAXN][MAXB], dep[MAXN];
bool vis[MAXN];
vector<int> g[MAXN], cir[MAXN];
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int b = MAXB - 1; b >= 0; b--)
if (dep[fa[u][b]] >= dep[v]) u = fa[u][b];
if (u == v) return u;
for (int b = MAXB - 1; b >= 0; b--)
if (fa[u][b] != fa[v][b]) u = fa[u][b], v = fa[v][b];
return fa[u][0];
}
inline int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
void dfs(int u, int f, int d) {
fa[u][0] = f;
dep[u] = d;
vis[u] = 1;
for (int b = 1; b < MAXB; b++) fa[u][b] = fa[fa[u][b - 1]][b - 1];
bool flag = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (!vis[v]) dfs(v, u, d + 1), flag = 1;
}
if (!flag) {
if (d >= (n - 1) / k + 1) {
printf("PATH\n%d\n", d);
for (int v = u; v; v = fa[v][0]) printf("%d ", v);
putchar('\n');
exit(0);
}
int x = 0, y = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v != f) {
if (x == 0)
x = v;
else {
y = v;
break;
}
}
}
c++;
if ((dist(u, x) + 1) % 3 != 0) {
int p = lca(u, x);
for (int v = u; v != p; v = fa[v][0]) cir[c].push_back(v);
int t = cir[c].size();
for (int v = x; v != fa[p][0]; v = fa[v][0]) cir[c].push_back(v);
reverse(cir[c].begin() + t, cir[c].end());
} else if ((dist(u, y) + 1) % 3 != 0) {
int p = lca(u, y);
for (int v = u; v != p; v = fa[v][0]) cir[c].push_back(v);
int t = cir[c].size();
for (int v = y; v != fa[p][0]; v = fa[v][0]) cir[c].push_back(v);
reverse(cir[c].begin() + t, cir[c].end());
} else {
cir[c].push_back(u);
int p = lca(x, y);
for (int v = x; v != p; v = fa[v][0]) cir[c].push_back(v);
int t = cir[c].size();
for (int v = y; v != fa[p][0]; v = fa[v][0]) cir[c].push_back(v);
reverse(cir[c].begin() + t, cir[c].end());
}
if (c == k) {
puts("CYCLES");
for (int i = 1; i <= k; i++) {
printf("%d\n", cir[i].size());
for (int j = 0; j < cir[i].size(); j++) printf("%d ", cir[i][j]);
putchar('\n');
}
exit(0);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
c = 0;
dfs(1, 0, 1);
puts("-1");
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long(n), (k);
scanf("%lld%lld", &(n), &(k));
;
vector<long long> A((n));
for (long long i = 0; i < n; i++) scanf("%lld", &A[i]);
;
vector<pair<long long, long long> > B;
for (long long i = 0; i < (n); i++) {
if (A[i] != 1) {
B.push_back({i, A[i]});
}
}
long long i = 0, j = 0, m = B.size(), count = 0;
while (i < n) {
if (j < m && i >= B[j].first) {
j++;
continue;
}
long long pro = A[i], sum = A[i];
if (pro >= k * sum && (pro - k * sum) % k == 0) {
long long q = (pro - k * sum) / k;
if (j == m) {
if (n - i - 1 >= q) count++;
} else if (B[j].first - i - 1 >= q) {
count++;
}
}
long long prev = i;
for (long long l = 0; l < (64); l++) {
if (j + l >= m) break;
if (B[j + l].second >= (2e18 + 1) / (double)pro ||
B[j + l].second >= ((long long)2e18 + 1) / pro)
break;
pro *= B[j + l].second;
sum += B[j + l].second + (B[j + l].first - prev - 1);
prev = B[j + l].first;
if (pro >= k * sum && (pro - k * sum) % k == 0) {
long long q = (pro - k * sum) / k;
if (j + l + 1 == m) {
if (n - B[j + l].first - 1 >= q) count++;
} else if (B[j + l + 1].first - B[j + l].first - 1 >= q) {
count++;
}
}
}
i++;
}
printf("%lld\n", count);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n < 2) return puts("0"), 0;
printf("%d", (n + 1) / 2 - 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, i0, n, a[100005], A, b[100005];
long long m, ans;
set<int> s;
int main() {
scanf("%d %lld", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d", &A);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
for (int i = 1; i <= n; i++) {
s.insert(b[i]);
while (s.size() && m < a[i]) {
ans += *s.begin();
s.erase(s.begin());
m += A;
}
if (m < a[i]) {
printf("-1\n");
return 0;
}
}
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int MOD = 1e9 + 7;
int n, a[N], nxt[1007];
vector<int> pos;
bool isLucky(int x) {
while (x > 0) {
if (x % 10 != 4 && x % 10 != 7) return false;
x /= 10;
}
return true;
}
long long tmp[5];
const long long x[] = {2, 3, 2, 2};
long long C(int n, int m) {
for (int i = (0); i < (m); ++i) tmp[i] = n - i;
int t = (m <= 3 ? m - 1 : m);
for (int i = (0); i < (t); ++i)
for (int j = (0); j < (m); ++j)
if (tmp[j] % x[i] == 0) {
tmp[j] /= x[i];
break;
}
long long r = 1;
for (int i = (0); i < (m); ++i) r *= tmp[i];
return r;
}
set<int> S;
set<int>::iterator L, R;
int main() {
scanf("%d", &n);
pos.push_back(-1);
for (int i = (0); i < (n); ++i) {
scanf("%d", &a[i]);
if (isLucky(a[i])) pos.push_back(i);
}
for (int i = (1); i < (((int)(pos).size())); ++i) {
nxt[i] = ((int)(pos).size());
for (int j = (i + 1); j < (((int)(pos).size())); ++j)
if (a[pos[i]] == a[pos[j]]) {
nxt[i] = j;
break;
}
}
long long ans = C(n, 4) + 2 * C(n, 3) + C(n, 2);
for (int i = (1); i < (((int)(pos).size()) - 1); ++i) {
S.clear();
S.insert(pos[i]), S.insert(n);
long long cnt = 0, ext = pos[i + 1] - pos[i];
for (int j = i; j >= 1; --j) {
if (nxt[j] > i) {
for (int k = nxt[j]; k < ((int)(pos).size()); k = nxt[k]) {
L = R = S.insert(pos[k]).first;
--L, ++R;
if (L == S.begin()) {
cnt += (*R - pos[k]) *
(ext * (ext + 1) / 2 + ext * (pos[k] - pos[i + 1]));
} else {
cnt += (*R - pos[k]) * (pos[k] - *L) * ext;
}
}
}
ans -= cnt * (pos[j] - pos[j - 1]);
}
}
printf("%lld\n", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string s, p;
int a[2005], dp[2005][2005];
int main() {
cin >> s >> p;
n = s.size();
m = p.size();
for (int i = 0; i < n; i++) {
int j;
for (j = 0; j < m && i + a[i] < n;) {
if (s[i + a[i]] == p[j]) j++;
a[i]++;
}
if (j < m) a[i] = -1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
if (a[i] >= 0)
dp[i + a[i]][j + a[i] - m] =
max(dp[i + a[i]][j + a[i] - m], dp[i][j] + 1);
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j]);
}
}
for (int i = 0; i <= n; i++) cout << dp[n][i] << ' ';
cout << '\n';
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > mas;
map<pair<int, int>, int> MI, MA;
int main() {
int n, m;
scanf("%d %d", &n, &m);
mas.resize(m);
for (int i = (0); i < (m); ++i) {
int cj, ci;
scanf("%d %d", &cj, &ci);
--cj;
--ci;
mas[i] = make_pair(cj, ci);
if (!((MI).find(make_pair(cj, -1)) != (MI).end()))
MI[make_pair(cj, -1)] = ci;
MI[make_pair(cj, -1)] =
((MI[make_pair(cj, -1)] <= ci) ? MI[make_pair(cj, -1)] : ci);
if (!((MA).find(make_pair(cj, -1)) != (MA).end()))
MA[make_pair(cj, -1)] = ci;
MA[make_pair(cj, -1)] =
((MA[make_pair(cj, -1)] >= ci) ? MA[make_pair(cj, -1)] : ci);
if (!((MI).find(make_pair(-1, ci)) != (MI).end()))
MI[make_pair(-1, ci)] = cj;
MI[make_pair(-1, ci)] =
((MI[make_pair(-1, ci)] <= cj) ? MI[make_pair(-1, ci)] : cj);
if (!((MA).find(make_pair(-1, ci)) != (MA).end()))
MA[make_pair(-1, ci)] = cj;
MA[make_pair(-1, ci)] =
((MA[make_pair(-1, ci)] >= cj) ? MA[make_pair(-1, ci)] : cj);
pair<int, int> v = make_pair(mas[i].first - ((cj <= ci) ? cj : ci),
mas[i].second - ((cj <= ci) ? cj : ci));
v.first += 1;
v.second += 1;
if (!((MI).find(v) != (MI).end())) MI[v] = ci;
MI[v] = ((MI[v] <= ci) ? MI[v] : ci);
if (!((MA).find(v) != (MA).end())) MA[v] = ci;
MA[v] = ((MA[v] >= ci) ? MA[v] : ci);
v = make_pair(mas[i].first + ((n - cj <= ci) ? n - cj : ci),
mas[i].second - ((n - cj <= ci) ? n - cj : ci));
v.first += 1;
v.second += 1;
v.first = -v.first;
v.second = -v.second;
if (!((MI).find(v) != (MI).end())) MI[v] = ci;
MI[v] = ((MI[v] <= ci) ? MI[v] : ci);
if (!((MA).find(v) != (MA).end())) MA[v] = ci;
MA[v] = ((MA[v] >= ci) ? MA[v] : ci);
}
int ans[16];
memset(ans, 0, sizeof(ans));
for (int i = (0); i < (m); ++i) {
int r = 0, mi, ma;
int cj = mas[i].first, ci = mas[i].second;
if (((MI).find(make_pair(cj, -1)) != (MI).end()) &&
((MA).find(make_pair(cj, -1)) != (MA).end())) {
mi = MI[make_pair(cj, -1)];
ma = MA[make_pair(cj, -1)];
if (mi < ci) ++r;
if (ma > ci) ++r;
}
if (((MI).find(make_pair(-1, ci)) != (MI).end()) &&
((MA).find(make_pair(-1, ci)) != (MA).end())) {
mi = MI[make_pair(-1, ci)];
ma = MA[make_pair(-1, ci)];
if (mi < cj) ++r;
if (ma > cj) ++r;
}
pair<int, int> v;
v = make_pair(mas[i].first - ((cj <= ci) ? cj : ci),
mas[i].second - ((cj <= ci) ? cj : ci));
v.first += 1;
v.second += 1;
if (((MI).find(v) != (MI).end()) && ((MA).find(v) != (MA).end())) {
mi = MI[v];
ma = MA[v];
if (mi < ci) ++r;
if (ma > ci) ++r;
}
v = make_pair(mas[i].first + ((n - cj <= ci) ? n - cj : ci),
mas[i].second - ((n - cj <= ci) ? n - cj : ci));
v.first += 1;
v.second += 1;
v.first = -v.first;
v.second = -v.second;
if (((MI).find(v) != (MI).end()) && ((MA).find(v) != (MA).end())) {
mi = MI[v];
ma = MA[v];
if (mi < ci) ++r;
if (ma > ci) ++r;
}
++ans[r];
}
for (int i = (0); i < (9); ++i) {
printf("%d", ans[i]);
if (i + 1 == 9)
printf("\n");
else
printf(" ");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 3e5 + 5;
int Head[MX], erear;
struct Edge {
int u, v, nxt, z;
} E[MX << 1];
void edge_init() {
erear = 0;
memset(Head, -1, sizeof(Head));
}
void edge_add(int u, int v, int z) {
E[erear].u = u;
E[erear].v = v;
E[erear].z = z;
E[erear].nxt = Head[u];
Head[u] = erear++;
}
int n, m;
int DFN[MX], Low[MX], dsz;
int Stack[MX], inStack[MX], Belong[MX], bsz, ssz;
int A[MX];
void trajan(int u, int e) {
inStack[u] = 1;
Stack[++ssz] = u;
DFN[u] = Low[u] = ++dsz;
for (int i = Head[u]; ~i; i = E[i].nxt) {
int v = E[i].v;
if ((i ^ 1) == e) continue;
if (!DFN[v]) {
trajan(v, i);
Low[u] = min(Low[u], Low[v]);
} else if (inStack[v]) {
Low[u] = min(Low[u], Low[v]);
}
}
if (DFN[u] == Low[u]) {
bsz++;
int v;
do {
v = Stack[ssz--];
inStack[v] = 0;
Belong[v] = bsz;
} while (ssz && v != u);
}
}
void tarjan_solve(int n) {
dsz = bsz = ssz = 0;
memset(DFN, 0, sizeof(DFN));
for (int i = 1; i <= n; i++) {
if (!DFN[i]) trajan(i, -1);
}
}
bool DFS(int st, int ed, int f, int s) {
s |= A[st];
if (st == ed) return s;
for (int i = Head[st]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (v == f) continue;
if (DFS(v, ed, st, s | E[i].z)) return true;
}
return false;
}
int main() {
edge_init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v, z;
scanf("%d%d%d", &u, &v, &z);
edge_add(u, v, z);
edge_add(v, u, z);
}
tarjan_solve(n);
int etot = erear;
edge_init();
for (int i = 0; i < etot; i++) {
int u = Belong[E[i].u], v = Belong[E[i].v];
if (u == v)
A[u] |= E[i].z;
else
edge_add(u, v, E[i].z);
}
int st, ed;
scanf("%d%d", &st, &ed);
if (DFS(Belong[st], Belong[ed], -1, 0)) {
printf("YES\n");
} else
printf("NO\n");
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, maxn = 23, maxl = 2e5 + 5;
inline int Add(int x, int y) { return (x += y) >= mod ? x - mod : x; }
inline int Mul(int x, int y) { return 1ll * x * y % mod; }
int n, cnt[maxn][26], f[1 << maxn], minx[26];
char s[maxl];
long long ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", s);
int len = strlen(s);
for (int j = 0; j < len; ++j) ++cnt[i][s[j] - 'a'];
}
for (int s = 1; s < 1 << n; ++s) {
for (int j = 0; j < 26; ++j) minx[j] = 1e9;
for (int i = 0; i < n; ++i)
if (s >> i & 1)
for (int j = 0; j < 26; ++j) minx[j] = min(minx[j], cnt[i][j]);
f[s] = __builtin_popcount(s) & 1 ? 1 : mod - 1;
for (int j = 0; j < 26; ++j) f[s] = Mul(f[s], minx[j] + 1);
}
for (int i = 0; i < n; ++i)
for (int s = 0; s < (1 << n); ++s)
if (s >> i & 1) f[s] = Add(f[s], f[s ^ (1 << i)]);
for (int s = 1; s < (1 << n); ++s) {
int res = 0;
for (int i = 0; i < n; ++i)
if (s >> i & 1) res += i + 1;
ans ^= 1ll * res * f[s] * __builtin_popcount(s);
}
printf("%lld\n", ans);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return (y ? gcd(y, x % y) : x); }
int main() {
int n, m;
map<int, int> a;
cin >> n;
m = n * n;
for (int i = 0; i < m; i++) {
int temp;
scanf("%d", &temp);
if (a.count(temp))
a[temp]++;
else
a[temp] = 1;
}
vector<pair<int, int> > ans;
while (m > 0) {
map<int, int>::reverse_iterator rhit = a.rbegin();
int cur = rhit->first;
int u = 0, v, k;
for (int i = 0; i < ans.size(); i++) {
if (ans[i].first % cur == 0) u += ans[i].second;
}
k = a[cur];
v = sqrt(0.0 + u * u + k) - u + 0.01;
for (int i = 0; i < ans.size(); i++) {
int g = gcd(ans[i].first, cur);
a[g] -= ans[i].second * v * 2;
m -= ans[i].second * v * 2;
if (a[g] == 0) a.erase(g);
}
a[cur] -= v * v;
m -= v * v;
if (a[cur] == 0) a.erase(cur);
ans.push_back(make_pair(cur, v));
}
for (int i = 0; i < ans.size(); i++)
for (int j = 0; j < ans[i].second; j++) cout << ans[i].first << ' ';
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int main() {
long long a, b, c, d;
while (~scanf("%lld%lld%lld%lld", &a, &b, &c, &d)) {
long long ans = 0;
for (long long i = a; i <= b; ++i) {
if (i + b <= c && i + c <= d) {
ans += i * (i + 1) / 2;
} else if (i + b <= c && i + c > d) {
ans += (d - c + 1) * (i + c - d - 1) + (d - c + 2) * (d - c + 1) / 2;
} else if (i + b > c && i + b <= d && i + c <= d) {
ans += (i - c + b) * (c - b + 1) + (1 + c - b) * (c - b) / 2;
} else if (i + b > c && i + b <= d && i + c > d) {
ans += (i + c - d) * (d - c + 1) + (d - i - b + 1) * (i + b - c) +
(1 + d - i - b) * (d - i - b) / 2;
} else if (i + b > d && i + c > d) {
ans += (d - c + 1) * (c - b + 1);
}
}
cout << ans << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << "Even" << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void getsolution(long long n, long long k) {
if (n >= k) {
cout << (n - k) % 2 << endl;
return;
} else {
cout << k - n << endl;
return;
}
}
int main() {
int t;
cin >> t;
while (t-- != 0) {
long long n, k;
cin >> n >> k;
getsolution(n, k);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Pair {
int l, r;
Pair(int ll, int rr) : l(ll), r(rr){};
};
vector<Pair> ans;
int a[3001];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
int mi = a[i], mp = i;
for (int j = i + 1; j <= n; j++) {
if (a[j] < mi) mi = a[j], mp = j;
}
if (i == mp) continue;
ans.push_back(Pair(i - 1, mp - 1));
swap(a[i], a[mp]);
}
printf("%d\n", ans.size());
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d %d\n", ans[i].l, ans[i].r);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int r, c, k;
char s[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
char gri[219][219];
char ans[219][219];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d%d", &r, &c, &k);
for (register int i = 1; i <= r; i++) scanf("%s", gri[i] + 1);
int cnt = 0;
for (register int i = 1; i <= r; i++)
for (register int j = 1; j <= c; j++)
if (gri[i][j] == 'R') cnt++;
int x = 1, y = 1, d = 1, num = cnt / k, num2 = cnt - k * num;
for (register int i = 1; i <= k; i++) {
int init;
if (!num2)
init = num;
else
num2--, init = num + 1;
if (i < k) {
while (init) {
if (gri[x][y] == 'R') init--;
ans[x][y] = s[i - 1];
y += d;
if (y > c)
x++, d = -d, y = c;
else if (y < 1)
x++, d = -d, y = 1;
}
} else {
while (x <= r) {
if (gri[x][y] == 'R') init--;
ans[x][y] = s[i - 1];
y += d;
if (y > c)
x++, d = -d, y = c;
else if (y < 1)
x++, d = -d, y = 1;
}
}
}
for (register int i = 1; i <= r; i++) {
for (register int j = 1; j <= c; j++) printf("%c", ans[i][j]);
printf("\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[2000005];
int deg[2000005];
bool u[2000005];
int n, m, cnt;
long long ans;
void dfs(int v) {
u[v] = 1;
if (deg[v] & 1) {
++cnt;
}
for (int to : adj[v]) {
if (u[to]) {
continue;
}
dfs(to);
}
}
void solve() {
scanf("%d %d", &n, &m);
for (int i = 1, l, r; i <= m; ++i) {
scanf("%d %d", &l, &r);
++deg[l], ++deg[r];
adj[l].push_back(r);
adj[r].push_back(l);
}
int p = 0;
for (int i = 1; i <= n; ++i) {
if (u[i]) {
continue;
}
if (i != 1 && adj[i].empty()) {
continue;
}
cnt = 0;
dfs(i);
if (cnt == 0) {
cnt = 2;
} else {
p = 100;
}
ans += cnt;
++p;
}
if (p == 1) {
ans = 0;
}
printf("%lld\n", ans / 2);
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
template <typename C>
void ma(C& a, C b) {
if (a < b) a = b;
}
template <typename C>
void mi(C& a, C b) {
if (a > b) a = b;
}
int n, m, dx, dy;
int wyn = 0;
int il[1001000];
int g[1001000];
int main() {
scanf("%d%d%d%d", &n, &m, &dx, &dy);
int akx = 0;
int aky = 0;
for (int i = 0; i < n; i++) {
g[akx] = aky;
akx += dx;
if (akx >= n) akx -= n;
aky += dy;
if (aky >= n) aky -= n;
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
il[(n + b - g[a]) % n]++;
}
int wyn = 0, gd = 0;
for (int i = 0; i < n; i++) {
if (il[i] > wyn) {
wyn = il[i];
gd = i;
}
}
printf("%d %d\n", 0, gd);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
int vis[(1 << 22)];
int mark[(1 << 22)];
void dfs(int s) {
if (vis[s]) return;
vis[s] = 1;
for (int i = 0; i < n; i++) {
if (s & (1 << i)) {
dfs(s - (1 << i));
}
}
if (mark[s]) dfs((1 << n) - 1 - s);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
mark[x] = 1;
}
int ans = 0;
for (int i = 0; i < (1 << n); i++) {
if (!vis[i] && mark[i]) {
dfs((1 << n) - 1 - i);
ans++;
}
}
cout << ans;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
int month[] = {-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const long double pie = 3.1415926535897932384626;
const long long mod = 1e9 + 7;
void solve(int test_case) {
int n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++)
for (int k = j; k < n; k++) ans = max(ans, (v[i] | v[j] | v[k]));
}
cout << ans;
cout << "\n";
;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 5e2 + 10;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main() {
double a, b, c;
cin >> a >> b >> c;
if (a < 0) {
a = -a;
b = -b;
c = -c;
}
double d = sqrt(b * b - 4 * a * c);
cout.precision(6);
cout << fixed << (-b + d) / (2 * a) << endl;
cout << fixed << (-b - d) / (2 * a) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, L, K;
double arr[205];
int bags[205];
double dp[205][205][205][2];
double solve(int i, int j, int a, int b) {
int a1 = a, b1 = b;
if (i == 0) {
if (j >= L && b == 1) {
return 1.0;
} else {
return 0.0;
}
}
double& ret = dp[i][j][a][b];
if (ret != -1.0) return ret;
ret = (1.0 - arr[i]) * solve(i - 1, j, a, b);
int x = bags[i];
if (bags[i] > 0) {
if (b == 0) {
if (a <= x) {
b = 1;
a = x - a;
} else {
a -= x;
}
} else {
a += x;
}
} else {
if (b == 0) {
a++;
} else if (a == 0) {
b = 0;
a++;
} else {
a--;
}
}
a = min(a, N);
ret += arr[i] * solve(i - 1, j + 1, a, b);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 0; i < 205; i++) {
for (int j = 0; j < 205; j++) {
for (int a = 0; a < 205; a++) {
for (int b = 0; b < 2; b++) {
dp[i][j][a][b] = -1;
}
}
}
}
cin >> N >> L >> K;
for (int i = 1, x; i <= N; i++) {
cin >> x;
arr[i] = 1.0 * x / 100;
}
for (int i = 1; i <= N; i++) {
cin >> bags[i];
}
cout << setprecision(16) << solve(N, 0, K, 1) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int A[200010];
int main() {
int N;
cin >> N;
int ans = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
ans += 1;
int lr = i;
while (lr < N && A[lr] == -1) lr += 1;
if (lr == N) break;
int next = lr + 1;
while (next < N && A[next] == -1) next += 1;
if (next == N) break;
int dist = next - lr;
if (abs(A[next] - A[lr]) % dist) {
i = next - 1;
continue;
}
int diff = (A[next] - A[lr]) / dist;
int r = next + 1;
if (A[lr] - (lr - i) * 1LL * diff <= 0) {
i = next - 1;
continue;
}
while (r < N) {
long long expectedvalue = A[next] + diff * 1LL * (r - next);
if (expectedvalue <= 0) break;
if (!(A[r] == -1 || A[r] == expectedvalue)) {
break;
}
r += 1;
}
i = r - 1;
}
cout << ans << endl;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const int INF = 2e9;
const long long LINF = 1e18 + 5;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
const int MN = 1e6 + 2;
bitset<1000005> b1;
bitset<1000005> b2;
int used[1000005];
int a[1002];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int x;
for (int i = 0; i < k; ++i) {
scanf("%d", &x);
used[x] = 1;
}
int kt = 0;
for (int i = 0; i < 1002; ++i) {
if (used[i]) {
a[kt++] = i;
}
}
k = kt;
if (n < a[0] || n > a[k - 1]) {
printf("-1\n");
return 0;
}
int ans = 1;
b1.reset();
b2.reset();
for (int i = 0; i < k; ++i) b1.set(a[i]);
while (1) {
if (b1.test(ans * n)) break;
b2 = b1;
b1.reset();
for (int i = 0; i < k; ++i) {
b1 |= (b2 << a[i]);
}
ans++;
}
printf("%d\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool x) { return (x ? "T" : "F"); }
string to_string(const char* s) { return to_string((string)s); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename V>
string to_string(V v) {
bool f = true;
string res = "[";
for (const auto& x : v) {
if (!f) res += ", ";
f = false;
res += to_string(x);
}
res += "]";
return res;
}
void debug() { cerr << endl; }
template <typename H, typename... T>
void debug(H h, T... t) {
cerr << " " << to_string(h);
debug(t...);
}
int n;
string s;
vector<int> d2;
void manacher() {
for (int i = 0, l = 0, r = -1; i < n; i++) {
int k = i > r ? 0 : min(d2[l + r - i + 1], r - i + 1);
while (0 <= i - k - 1 && i + k < n && s[i - k - 1] == s[i + k]) {
k++;
}
d2[i] = k--;
if (i + k > r) {
l = i - k - 1;
r = i + k;
}
}
}
void solve() {
cin >> n;
string t;
cin >> t;
s.resize(2 * n);
for (int i = 0; i < n; i++) {
s[2 * i] = t[i];
s[2 * n - 2 * i - 1] = t[i];
}
d2.resize(2 * n);
n *= 2;
manacher();
n /= 2;
int m = n / 2;
vector<int> mx(n, -1);
for (int i = 0; i < m; i++) {
int j = 2 * i + 1;
if (d2[j] % 2 == 0) d2[j]--;
if (d2[j] > 0) {
int k = (j - d2[j]) / 2;
mx[k] = max(mx[k], d2[j]);
}
}
2019;
for (int i = 1; i < m; i++) {
mx[i] = max(mx[i], mx[i - 1] - 2);
}
for (int i = 0; i < m; i++) {
if (mx[i] <= 0) mx[i] = -1;
cout << mx[i] << ' ';
}
if (n & 1) cout << -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = 20;
int n;
int a[2][2 * maxn];
bool read() {
if (scanf("%d", &n) < 1) {
return false;
}
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2 * n + 1; j++) {
scanf(" ");
char c = getchar();
if (c == 'E') {
a[i][j] = -1;
continue;
}
ungetc(c, stdin);
scanf("%d", &a[i][j]);
a[i][j]--;
}
}
return true;
}
const int gox[] = {1, 0, -1, 0};
const int goy[] = {0, 1, 0, -1};
const string chs = "drul";
string ans;
vector<string> ops;
int rots[2][2];
int ex, ey;
void getPos(int id, int &x, int &y) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2 * n + 1; j++) {
if (a[i][j] == id) {
x = i;
y = j;
return;
}
}
}
assert(false);
}
void move(int dir) {
int nx = ex + gox[dir], ny = ey + goy[dir];
swap(a[ex][ey], a[nx][ny]);
ex = nx;
ey = ny;
ans += chs[dir];
}
void rot(int c, int dir) {
if (!c) {
int tmp = a[0][0];
if (!dir) {
for (int i = 0; i < n; i++) {
a[0][i] = a[0][i + 1];
}
a[0][n] = a[1][n - 1];
for (int i = n - 1; i > 0; i--) {
a[1][i] = a[1][i - 1];
}
a[1][0] = tmp;
} else {
a[0][0] = a[1][0];
for (int i = 0; i < n - 1; i++) {
a[1][i] = a[1][i + 1];
}
a[1][n - 1] = a[0][n];
for (int i = n; i > 1; i--) {
a[0][i] = a[0][i - 1];
}
a[0][1] = tmp;
}
} else {
int tmp = a[0][2 * n];
if (!dir) {
for (int i = 2 * n; i > n; i--) {
a[0][i] = a[0][i - 1];
}
a[0][n] = a[1][n + 1];
for (int i = n + 1; i < 2 * n; i++) {
a[1][i] = a[1][i + 1];
}
a[1][2 * n] = tmp;
} else {
a[0][2 * n] = a[1][2 * n];
for (int i = 2 * n; i > n + 1; i--) {
a[1][i] = a[1][i - 1];
}
a[1][n + 1] = a[0][n];
for (int i = n; i < 2 * n - 1; i++) {
a[0][i] = a[0][i + 1];
}
a[0][2 * n - 1] = tmp;
}
}
ans += (char)('A' + rots[c][dir]);
}
void moveToMiddle(int id) {
int x, y;
getPos(id, x, y);
while (a[0][n] != id) {
rot(y > n, 0);
}
}
int t;
void swp(int i, int j, int x, int y, int c) {
if (j == i) {
return;
}
moveToMiddle(i);
rot(!c, t);
int bad = a[0][n];
moveToMiddle(j);
rot(!c, !t);
moveToMiddle(bad);
rot(!c, t);
while (a[x][y] != i) {
rot(c, 0);
}
t = !t;
}
void solve() {
ans = "";
ops.clear();
getPos(-1, ex, ey);
{
while (ey != n) {
move(ey < n ? 1 : 3);
}
if (!ex) {
move(0);
}
}
for (int c = 0; c < 2; c++) {
for (int dir = 0; dir < 2; dir++) {
rots[c][dir] = ((int)(ops).size());
string s;
if (dir) {
s += 'u';
}
for (int i = 0; i < n; i++) {
s += (c ? 'r' : 'l');
}
if (!dir) {
s += 'u';
}
if (dir) {
s += 'd';
}
for (int i = 0; i < n; i++) {
s += (c ? 'l' : 'r');
}
if (!dir) {
s += 'd';
}
ops.push_back(s);
}
}
for (int i = 0; i < n; i++) {
swp(i, a[0][i], 0, i, 0);
}
for (int i = 0; i < n; i++) {
swp(2 * n + 1 + i, a[1][i], 1, i, 0);
}
for (int i = 0; i < n; i++) {
swp(n + 1 + i, a[0][n + 1 + i], 0, n + 1 + i, 1);
}
for (int i = 0; i < n; i++) {
swp(3 * n + 1 + i, a[1][n + 1 + i], 1, n + 1 + i, 1);
}
if (a[0][0] != 0) {
printf("SURGERY FAILED\n");
return;
}
for (int i = 0; i < n; i++) {
move(1);
}
printf("SURGERY COMPLETE\n");
printf("%s\n", ans.c_str());
for (int i = 0; i < ((int)(ops).size()); i++) {
printf("%c %s\n", (char)('A' + i), ops[i].c_str());
}
printf("DONE\n");
}
int main() {
precalc();
int t;
scanf("%d", &t);
while (read()) {
solve();
}
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.000000000000001;
int uni[200005], k, vis[200005];
long long ans = 0;
vector<int> G[200005];
int DFS(int src) {
vis[src] = 1;
int below = uni[src];
for (int i = 0; i < G[src].size(); ++i) {
if (!vis[G[src][i]]) below += DFS(G[src][i]);
}
ans += min(below, 2 * k - below);
return below;
}
int main(int argc, char const *argv[]) {
int n, i, j;
scanf("%d%d", &n, &k);
;
for (i = 0; i < 2 * k; ++i) {
int x;
scanf("%d", &x);
;
uni[x] = 1;
}
for (i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
;
G[x].push_back(y);
G[y].push_back(x);
}
DFS(1);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int inf = 99999999, P = 1000000007;
int maxdfn, maxcol, m;
int _last[4000005], _next[4000005], x[4000005], y[4000005], e;
int dfn[400005], low[400005], in[400005];
int sta[400005], col[400005], s[400005], z;
int c[200005];
inline void edge(int u, int v) {
e++;
x[e] = u;
y[e] = v;
_next[e] = _last[u];
_last[u] = e;
}
int tarjan(int pos) {
if (dfn[pos]) {
if (in[pos]) return dfn[pos];
return inf;
}
dfn[pos] = low[pos] = ++maxdfn;
in[sta[++z] = pos] = 1;
for (int j = _last[pos]; j != -1; j = _next[j]) {
low[pos] = min(low[pos], tarjan(y[j]));
}
if (dfn[pos] == low[pos]) {
int j = z;
maxcol++;
if (maxcol == 2) {
puts("NO");
exit(0);
}
while (sta[j] != pos) {
j--;
}
for (int i = j; i <= z; i++) {
in[sta[i]] = 0;
col[sta[i]] = maxcol;
}
s[maxcol] = z - j + 1;
z = j - 1;
}
return low[pos];
}
int Min[200005], cnt[200005];
int aledge[200005], ot[200005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) _last[i] = -1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int t;
scanf("%d", &t);
if (t) {
edge(i, j);
}
}
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
puts("YES");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l = 0, r = 0, d = 0, u = 0, x, y;
string str;
cin >> n >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'L')
l++;
else if (str[i] == 'R')
r++;
else if (str[i] == 'D')
d++;
else if (str[i] == 'U')
u++;
}
x = min(l, r);
y = min(u, d);
l = l - x;
r = r - x;
u = u - y;
d = d - y;
cout << n - (l + r + u + d) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int N = 2750132;
int lp[N + 1];
int dove[N + 1];
vector<int> pr;
void sieve() {
for (int i = 2; i <= N; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= N; ++j)
lp[i * pr[j]] = pr[j];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
sieve();
for (int i = 0; i < pr.size(); i++) {
dove[pr[i]] = i + 1;
}
int n;
cin >> n;
multiset<int> a;
for (int i = 0; i < 2 * n; i++) {
int val;
cin >> val;
a.insert(val);
}
vector<int> ans;
while (!a.empty()) {
int curr = *a.rbegin();
if (lp[curr] != curr) {
int val = curr / lp[curr];
auto it = a.lower_bound(val);
a.erase(it);
ans.push_back(curr);
} else {
int val = dove[curr];
auto it = a.lower_bound(val);
ans.push_back(*it);
a.erase(it);
}
a.erase(prev(a.end()));
}
for (auto it : ans) {
cout << it << " ";
}
cout << '\n';
}
| 10 |
#include <bits/stdc++.h>
const double EPS = 1e-24;
const long long MOD = 1000000007ll;
const double PI = 3.14159265359;
long long INF = 1e18;
template <class T>
T Max2(T a, T b) {
return a < b ? b : a;
}
template <class T>
T Min2(T a, T b) {
return a < b ? a : b;
}
template <class T>
T Max3(T a, T b, T c) {
return Max2(Max2(a, b), c);
}
template <class T>
T Min3(T a, T b, T c) {
return Min2(Min2(a, b), c);
}
template <class T>
T Max4(T a, T b, T c, T d) {
return Max2(Max2(a, b), Max2(c, d));
}
template <class T>
T Min4(T a, T b, T c, T d) {
return Min2(Min2(a, b), Max2(c, d));
}
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
vector<int> G[1000010];
int vis[1000010];
long long fact[1000010];
void compute() {
long long a = 1;
fact[1] = 1;
for (int i = 2; i < 1000010; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
fact[i] %= MOD;
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
compute();
for (int i = 1; i <= n; i++) {
int g;
cin >> g;
for (int j = 0; j < g; j++) {
int x;
cin >> x;
G[x].push_back(i);
}
}
long long ans = 1;
sort(G + 1, G + m + 1);
long long cnt = 1;
for (int i = 2; i <= m; i++) {
if (G[i] == G[i - 1]) {
cnt++;
} else {
ans = (ans * fact[cnt]) % MOD;
cnt = 1;
}
}
ans = (ans * fact[cnt]) % MOD;
cout << ans % MOD << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int N = 1010;
int n, i, j, k, x, a[N], g[N][N][8], v[8], f[256][10], ans;
inline void umin(int& a, int b) {
if (a > b) a = b;
}
inline void umax(int& a, int b) {
if (a < b) a = b;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), a[i]--;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n + 5; j++)
for (k = 0; k < 8; k++) g[i][j][k] = n + 10;
for (j = 0; j < 8; j++) v[j] = 0;
for (j = i; j <= n; j++) g[i][++v[a[j]]][a[j]] = j;
}
for (x = 0; x * 8 <= n; x++) {
for (i = 0; i < 256; i++)
for (j = 0; j <= 8; j++) f[i][j] = n + 10;
f[0][0] = 1;
for (i = 0; i < 256; i++)
for (j = 0; j <= 8; j++)
if (f[i][j] <= n)
for (k = 0; k < 8; k++)
if (!(i >> k & 1)) {
umin(f[i | (1 << k)][j], g[f[i][j]][x][k] + 1);
umin(f[i | (1 << k)][j + 1], g[f[i][j]][x + 1][k] + 1);
}
for (j = 0; j <= 8; j++)
if (f[255][j] <= n + 1) umax(ans, (8 - j) * x + j * (x + 1));
}
printf("%d", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long a[2000][2000 / 63 + 1], p[63];
int b[2000], c[2000], n, t, i, j, k, nn;
bool f;
int main() {
scanf("%d", &n);
nn = n / 63 + 1;
for (i = 0; i < 63; i++) p[i] = 1ULL << i;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
scanf("%d", &t);
if (t) a[i][j / 63] |= p[j % 63];
}
for (k = 0; k < n; k++)
for (i = 0; i < n; i++)
if (a[i][k / 63] & p[k % 63])
for (j = 0; j < nn; j++) a[i][j] |= a[k][j];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (a[i][j / 63] & p[j % 63]) ++b[i], ++c[j];
for (i = 0; !f && i < n; i++)
if (b[i] == n && c[i] == n) f = 1;
cout << (f ? "YES" : "NO") << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000, M = 2000;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
string str;
cin >> str;
int ans = 0;
for (int i = 0; i < n; i++) {
if (str[i] != '<') break;
ans++;
}
for (int i = n - 1; i >= 0; i--) {
if (str[i] != '>') break;
ans++;
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string TS(T ss) {
ostringstream oss;
oss << ss;
return oss.str();
}
template <class T>
T ABS(T n) {
return (n >= 0 ? n : -n);
}
template <class T>
T BP(T n, long long int k) {
T res = 1;
while (k) {
if (k & 1) {
res *= n;
}
n *= n;
k >>= 1;
}
return res;
}
struct ST {
long long int v, k, d;
ST(long long int v, long long int k, long long int d) : v(v), k(k), d(d) {}
ST(long long int v, long long int k) : v(v), k(k) {}
ST() {}
bool operator<(const ST &it) const { return v < it.v; }
};
char buf[(int)1e6 + 10], buf1[(int)1e6 + 10];
long long int n = 0, m = 0, k = 0;
vector<long long int> v;
void task() {
long long int a, b, c, d;
cin >> n >> a >> b >> c >> d;
v.resize(4);
vector<long long int> v1(10, 0);
v1[0] = 1;
v[0] = a + b;
v[1] = a + c;
v[2] = b + d;
v[3] = c + d;
sort((v).begin(), (v).end());
for (int i = 1; i < 4; i++) {
if (v[i] == v[i - 1]) {
v1[i] = v1[i - 1];
} else {
v1[i] = v1[i - 1] + v[i] - v[i - 1];
}
}
if (n - v1[3] >= 0) {
cout << (n - v1[3] + 1) * n;
} else {
cout << 0;
}
}
int main() {
task();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 998244353;
long long sum, arr[N];
vector<int> v;
string s, t;
int n, m;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
arr[0] = 1;
for (int i = 1; i < N; ++i) (arr[i] = arr[i - 1] * 2) %= mod;
cin >> n >> m >> s >> t;
while (s.size() < t.size()) s = '0' + s;
while (t.size() < s.size()) t = '0' + t;
n = max(n, m);
for (int i = 0; i < n; ++i)
if (t[i] == '1') v.push_back(i);
for (int i = 0; i < n; ++i)
if (s[i] == '1')
(sum += arr[n - i - 1] *
(upper_bound(v.begin(), v.end(), i) - v.begin())) %= mod;
cout << sum;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> Set;
pair<int, int> c[181], d[181];
int a, b, n, m, i, j, k, nom, ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++) c[i].first = 2000000000;
for (i = 1; i <= m; i++) {
cin >> a >> b;
c[a].second++;
if (a < b)
c[a].first = min(c[a].first, b - a);
else
c[a].first = min(c[a].first, n - (a - b));
}
for (i = 1; i <= n; i++) d[i] = c[i];
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) c[j] = d[j];
nom = i;
ans = 0;
k = m;
Set.clear();
while (true) {
if (Set.find(nom) != Set.end()) Set.erase(nom);
if (k == 0 && Set.empty()) break;
if (c[nom].second == 0) {
ans++;
nom++;
if (nom > n) nom -= n;
continue;
}
if (c[nom].second == 1) {
if (nom + c[nom].first <= n)
Set.insert(nom + c[nom].first);
else
Set.insert(nom + c[nom].first - n);
}
c[nom].second--;
k--;
ans++;
nom++;
if (nom > n) nom -= n;
}
cout << ans << " ";
}
cout << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
int a[102] = {};
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int min = 1 << 20;
int ans_i = 0;
int ans_j = 0;
for (int i = 0; i < n; ++i) {
if (min > abs(a[i] - a[(i + 1) % n])) {
min = abs(a[i] - a[(i + 1) % n]);
ans_i = i;
ans_j = (i + 1) % n;
}
}
cout << (ans_i + 1) << " " << (ans_j + 1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct Set {
int head, tail, size;
Set(int x) {
head = x;
tail = x;
size = 1;
}
Set() { head = tail = size = 0; }
} s[100005];
int a[100005], Next[100005], head[100005];
void MakeSet(int x) {
s[x] = Set(x);
head[x] = x;
Next[x] = -1;
}
int FindSet(int x) { return head[x]; }
void Union(int x, int y) {
if (s[x].size == 0 || s[y].size == 0) return;
if (s[x].size < s[y].size) swap(x, y);
Next[s[x].tail] = s[y].head;
s[x].tail = s[y].tail;
s[x].size += s[y].size;
head[s[y].tail] = s[x].head;
for (int node = s[y].head; node != s[y].tail; node = Next[node])
head[node] = s[x].head;
}
bool mark[100005];
pair<int, int> p[100005];
vector<int> v[100005];
long long comb(long long n) {
if (n % 2 == 0)
return n / 2 * (n - 1);
else
return (n - 1) / 2 * n;
}
long long f(int x) {
long long ans = 0;
mark[x] = true;
vector<int> size;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
int yn = FindSet(y), xn = FindSet(x);
if (mark[y] && yn != xn) {
size.push_back(s[yn].size);
Union(xn, yn);
}
}
ans = comb(s[FindSet(x)].size - 1);
for (int i = 0; i < size.size(); i++) ans += size[i] - comb(size[i]);
return ans;
}
int main() {
long long n, m, x, y, sum = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
MakeSet(i);
cin >> a[i];
p[i].first = a[i];
p[i].second = i;
}
sort(p, p + n);
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = n - 1; i >= 0; i--) sum += f(p[i].second) * p[i].first;
printf("%0.6f\n", double(sum) / comb(n));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 55;
struct W {
int x, y, tx, ty, id;
} up[N], down[N];
bool cmp_down(W a, W b) { return a.tx == b.tx ? a.ty < b.ty : a.tx > b.tx; }
bool cmp_up(W a, W b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
vector<pair<int, int> > ans_fr, ans_to;
bool has[N][N];
void move_up(int& x, int y) {
int dx = x;
has[x][y] = 0;
has[x - 1][y] = 1;
ans_fr.push_back(make_pair(dx, y));
ans_to.push_back(make_pair(dx - 1, y));
--x;
}
void move_down(int& x, int y) {
int dx = x;
has[x][y] = 0;
has[x + 1][y] = 1;
ans_fr.push_back(make_pair(dx, y));
ans_to.push_back(make_pair(dx + 1, y));
++x;
}
void move_left(int x, int& y) {
int dy = y;
has[x][y] = 0;
has[x][y - 1] = 1;
ans_fr.push_back(make_pair(x, dy));
ans_to.push_back(make_pair(x, dy - 1));
--y;
}
void move_right(int x, int& y) {
int dy = y;
has[x][y] = 0;
has[x][y + 1] = 1;
ans_fr.push_back(make_pair(x, dy));
ans_to.push_back(make_pair(x, dy + 1));
++y;
}
void move_row(int& x, int& y, int tx, int ty) {
while (y < ty && has[x][y + 1] == 0) {
move_right(x, y);
}
while (y > ty && has[x][y - 1] == 0) {
move_left(x, y);
}
}
void move(int& x, int& y, int tx, int ty) {
while (x < tx) {
move_down(x, y);
}
while (x > tx) {
move_up(x, y);
}
while (y < ty) {
move_right(x, y);
}
while (y > ty) {
move_left(x, y);
}
}
int check(W a) {
if (a.x == a.tx) {
return a.y == a.ty ? 0 : 1;
} else {
return a.y == a.ty ? 2 : 3;
}
}
int nx[N], ny[N];
char mp[N][N];
int vis[N];
void write(int n) {
for (int i = 1; i <= n; i++) {
cout << mp[i] + 1 << endl;
}
puts("----------------------");
}
void deal(int n, int m) {
if (n == 1) {
puts("0");
} else {
if (m == 1) {
move(up[1].x, up[1].y, up[1].tx, up[1].ty);
} else {
if (cmp_up(up[1], up[2]) == 0) {
swap(up[1], up[2]);
}
if (up[1].x == 2) {
move_up(up[1].x, up[1].y);
move_up(up[2].x, up[2].y);
} else if (up[2].x == 2) {
move_up(up[2].x, up[2].y);
}
switch (check(up[1])) {
case 0:
break;
case 1:
move(up[2].x, up[2].y, 2, 1);
move_right(up[1].x, up[1].y);
break;
case 2:
move(up[1].x, up[1].y, up[1].tx, up[1].ty);
break;
case 3:
move(up[1].x, up[1].y, up[1].tx, up[1].ty);
move_left(up[2].x, up[2].y);
break;
}
move(up[2].x, up[2].y, up[2].tx, up[2].ty);
}
cout << ans_fr.size() << endl;
for (int i = 0; i < ans_fr.size(); i++) {
int xx1 = ans_fr[i].first, xx2 = ans_to[i].first;
int yy1 = ans_fr[i].second, yy2 = ans_to[i].second;
printf("%d %d %d %d\n", xx1, yy1, xx2, yy2);
mp[xx2][yy2] = mp[xx1][yy1];
mp[xx1][yy1] = '.';
}
}
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
mp[i][j] = '.';
}
}
for (int i = 1; i <= m; i++) {
up[i].id = i;
nx[i] = up[i].x = read();
ny[i] = up[i].y = read();
has[nx[i]][ny[i]] = 1;
mp[nx[i]][ny[i]] = i + '0';
}
for (int i = 1; i <= m; i++) {
up[i].tx = read();
up[i].ty = read();
}
if (n <= 2) {
deal(n, m);
return 0;
}
copy(up + 1, up + 1 + m, down + 1);
sort(up + 1, up + 1 + m, cmp_up);
int cnt = m;
while (cnt) {
bool flag = 0;
for (int i = 1; i <= m; i++) {
if (vis[i] == 0) {
int id = up[i].id;
move_row(nx[id], ny[id], 1, i);
if (ny[id] == i) {
vis[i] = 1;
cnt--;
flag = 1;
}
}
}
if (!flag) {
return 0;
}
}
for (int i = 1; i <= m; i++) {
int id = up[i].id;
while (nx[id] > 1) {
move_up(nx[id], ny[id]);
}
}
for (int i = 1; i <= m; i++) {
move_down(nx[i], ny[i]);
move_down(nx[i], ny[i]);
}
sort(down + 1, down + 1 + m, cmp_down);
for (int i = 1; i <= m; i++) {
int id = down[i].id;
move_up(nx[id], ny[id]);
move_row(nx[id], ny[id], 1, i);
move_up(nx[id], ny[id]);
}
for (int i = 1; i <= m; i++) {
int id = down[i].id;
while (nx[id] < down[i].tx) {
move_down(nx[id], ny[id]);
}
}
cnt = m;
while (cnt) {
bool flag = 0;
for (int i = 1; i <= m; i++) {
if (vis[i] == 1) {
int id = down[i].id;
move_row(nx[id], ny[id], nx[id], down[i].ty);
if (ny[id] == down[i].ty) {
vis[i] = 2;
cnt--;
flag = 1;
}
}
}
if (!flag) {
return 1;
}
}
assert(ans_fr.size() == ans_to.size());
assert(ans_fr.size() <= 10800);
cout << ans_fr.size() << endl;
for (int i = 0; i < ans_fr.size(); i++) {
int xx1 = ans_fr[i].first, xx2 = ans_to[i].first;
int yy1 = ans_fr[i].second, yy2 = ans_to[i].second;
printf("%d %d %d %d\n", xx1, yy1, xx2, yy2);
mp[xx2][yy2] = mp[xx1][yy1];
mp[xx1][yy1] = '.';
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ct[2 * 100005] = {0};
long long arr[2 * 100005] = {0};
long long mct = 0, mx = -1;
arr[0] = -1;
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
ct[arr[i]]++;
if (ct[arr[i]] > mct) {
mct = ct[arr[i]];
mx = arr[i];
}
}
vector<long long> pos;
pos.emplace_back(-1);
for (long long i = 1; i <= n; i++) {
if (arr[i] == mx) {
pos.emplace_back(i);
arr[i] = -1;
}
}
vector<pair<long long, pair<long long, long long>>> ans;
for (long long i = 1; i < pos.size(); i++) {
long long j = pos[i];
while (arr[j - 1] != -1) {
if (arr[j - 1] > mx)
ans.emplace_back(make_pair(2, make_pair(j - 1, j)));
else
ans.emplace_back(make_pair(1, make_pair(j - 1, j)));
arr[j] = -1;
arr[j - 1] = -1;
j--;
}
}
for (long long i = pos[pos.size() - 1]; i <= n - 1; i++) {
if (arr[i + 1] > mx)
ans.emplace_back(make_pair(2, make_pair(i + 1, i)));
else
ans.emplace_back(make_pair(1, make_pair(i + 1, i)));
}
cout << n - (pos.size() - 1) << '\n';
for (long long i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << (ans[i].second).first << " "
<< (ans[i].second).second << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1e9 + 7;
const int64_t N = 1e6 + 5;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int64_t t;
cin >> t;
while (t--) {
int64_t n;
cin >> n;
string a, b;
cin >> a >> b;
vector<int64_t> ans;
for (int64_t i = n - 1; i >= 0; i--) {
if (a[i] == b[i]) continue;
if (a[0] != b[i]) {
ans.push_back(i + 1);
int64_t l = 0;
int64_t r = i;
while (l <= r) {
if (a[l] == '1') {
a[l] = '0';
} else {
a[l] = '1';
}
if (l != r) {
if (a[r] == '1') {
a[r] = '0';
} else {
a[r] = '1';
}
}
swap(a[l], a[r]);
l++;
r--;
}
} else {
if (a[0] == '1') {
a[0] = '0';
} else {
a[0] = '1';
}
int64_t l = 0;
int64_t r = i;
while (l <= r) {
if (a[l] == '1') {
a[l] = '0';
} else {
a[l] = '1';
}
if (l != r) {
if (a[r] == '1') {
a[r] = '0';
} else {
a[r] = '1';
}
}
swap(a[l], a[r]);
l++;
r--;
}
ans.push_back(1);
ans.push_back(i + 1);
}
}
cout << ans.size() << " ";
for (int64_t i : ans) cout << i << " ";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
vector<double> coords = vector<double>(5);
};
struct vec {
vector<double> coords = vector<double>(5);
double length;
};
int main() {
int n;
cin >> n;
vector<point> points(n);
for (int i = 0; i < n; i++)
for (int j = 0; j < 5; j++) cin >> points[i].coords[j];
bool ans[n];
for (int i = 0; i < n; i++) ans[i] = true;
int k_good = n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = j + 1; k < n; k++) {
if (i != j && i != k && j != k && ans[i]) {
vec vecij;
vec vecik;
double sum_forl1 = 0;
double sum_forl2 = 0;
double vec_pow = 0;
for (int n = 0; n < 5; n++) {
vecij.coords[n] = points[j].coords[n] - points[i].coords[n];
vecik.coords[n] = points[k].coords[n] - points[i].coords[n];
sum_forl1 += vecij.coords[n] * vecij.coords[n];
sum_forl2 += vecik.coords[n] * vecik.coords[n];
vec_pow += vecik.coords[n] * vecij.coords[n];
}
vec_pow = sqrt(vec_pow);
vecij.length = sqrt(sum_forl1);
vecik.length = sqrt(sum_forl2);
if (acos(vec_pow / (vecij.length * vecik.length)) * 180 / 3.14159265 <
90) {
ans[i] = false;
k_good--;
} else
ans[i] = true;
}
}
cout << k_good << '\n';
for (int i = 0; i < n; i++)
if (ans[i]) cout << i + 1 << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, v[104], k, nr0;
int** mat;
int _pow(int a, int b) {
if (b == 0) return 1;
if (b == 1) return a;
if (b % 2 == 0) return _pow(1LL * a * a % 1000000007, b / 2);
return 1LL * _pow(1LL * a * a % 1000000007, b / 2) * a % 1000000007;
}
int** mult(int** A, int** B) {
int** ans = new int*[nr0 + 1];
for (int i = 0; i <= nr0; i++) ans[i] = new int[nr0 + 1];
for (int i = 0; i <= nr0; i++)
for (int j = 0; j <= nr0; j++) ans[i][j] = 0;
for (int i = 0; i <= nr0; i++)
for (int j = 0; j <= nr0; j++) {
for (int k = 0; k <= nr0; k++) {
ans[i][j] = (1LL * A[i][k] * B[k][j] + ans[i][j]) % 1000000007;
}
}
return ans;
}
int** _pow2(int** mat, int k) {
int** mat2 = new int*[nr0 + 1];
for (int i = 0; i <= nr0; i++) mat2[i] = new int[nr0 + 1];
for (int i = 0; i <= nr0; i++)
for (int j = 0; j <= nr0; j++) mat2[i][j] = mat[i][j];
if (k == 1) return mat2;
int** mat3 = new int*[nr0 + 1];
for (int i = 0; i <= nr0; i++) mat3[i] = new int[nr0 + 1];
for (int i = 0; i <= nr0; i++)
for (int j = 0; j <= nr0; j++) mat3[i][j] = mat[i][j];
if (k % 2 == 0) {
mat3 = mult(mat3, mat2);
return _pow2(mat3, k / 2);
} else {
mat3 = mult(mat3, mat2);
mat3 = _pow2(mat3, k / 2);
return mult(mat3, mat2);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> v[i];
if (v[i] == 0) nr0++;
}
if (nr0 == 0 || nr0 == n) {
cout << 1 << '\n';
return 0;
}
mat = new int*[nr0 + 1];
for (int i = 0; i <= nr0; i++) {
mat[i] = new int[nr0 + 1];
for (int j = 0; j <= nr0; j++) {
mat[i][j] = 0;
}
}
int mn = max(0, nr0 - (n - nr0));
for (int i = 0; i <= nr0; i++) {
if (i > mn)
mat[i - 1][i] = 1LL * (nr0 - (i - 1)) * (nr0 - (i - 1)) % 1000000007;
mat[i][i] = ((max(0LL, 1LL * nr0 * (nr0 - 1) / 2) +
max(0LL, 1LL * (n - nr0) * (n - nr0 - 1) / 2)) %
1000000007 +
1LL * (nr0 - i) * i) %
1000000007;
mat[i][i] =
(mat[i][i] + 1LL * (nr0 - i) * (n - nr0 - (nr0 - i))) % 1000000007;
if (i < nr0)
mat[i + 1][i] = 1LL * (i + 1) * (n - nr0 - (nr0 - i - 1)) % 1000000007;
}
int** ans = _pow2(mat, k);
for (int i = 0; i <= nr0; i++)
for (int j = 0; j <= nr0; j++) mat[i][j] = 0;
int x = 0;
for (int i = 1; i <= nr0; i++)
if (v[i] == 0) x++;
mat[1][x] = 1;
int** ans2 = mult(mat, ans);
int A = ans2[1][nr0], B = 0;
for (int i = 0; i <= nr0; i++) B = (B + ans2[1][i]) % 1000000007;
A = (1LL * A * _pow(B, 1000000007 - 2)) % 1000000007;
cout << A << '\n';
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
long long int x = n / 2;
long long int ans = x + 1;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int E;
cin >> E;
int arr[N + 1];
memset(arr, 0, sizeof(arr));
for (int i = 0; i < E; i++) {
int a, b, e;
cin >> a >> b >> e;
arr[a] -= e;
arr[b] += e;
}
int debt = 0;
for (int i = 1; i <= N; i++) {
if (arr[i] >= 0) debt += arr[i];
}
cout << debt << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long mod = 998244353;
long long ksm(long long t, long long x) {
long long ans = 1;
for (; x; x >>= 1, t = t * t % mod)
if (x & 1) ans = ans * t % mod;
return ans;
}
int n, a[2005], b[2005], cnt[3], opp[2005], exi[2005], exb[2005], tag[2005],
cir;
long long S[2005][2005], C[2005][2005], fac[2005], ifac[2005], f[2005], g[2005];
void dfs(int v, int f) {
tag[v] = 1;
if (!b[v]) {
if (!f)
cnt[2]++;
else
cnt[1]++;
return;
}
if (exi[b[v]]) {
if (tag[exi[b[v]]])
cir++;
else
dfs(exi[b[v]], f);
} else if (!f)
cnt[0]++;
}
long long h[2005], ans[2005];
int main() {
n = Get();
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
ifac[n] = ksm(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
C[i][j] = (!j || i == j) ? 1 : (C[i - 1][j - 1] + C[i - 1][j]) % mod;
S[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
S[i][j] = (S[i - 1][j - 1] + S[i - 1][j] * (i - 1)) % mod;
for (int i = 1; i <= n; i++) a[i] = Get();
for (int i = 1; i <= n; i++) b[i] = Get();
for (int i = 1; i <= n; i++)
if (a[i]) exi[a[i]] = i;
for (int i = 1; i <= n; i++)
if (b[i]) exb[b[i]] = i;
for (int i = 1; i <= n; i++) {
if (a[i] && exb[a[i]]) continue;
dfs(i, a[i]);
}
for (int i = 1; i <= n; i++)
if (!tag[i]) dfs(i, a[i]);
for (int i = 0; i <= cnt[0]; i++)
for (int j = i; j <= cnt[0]; j++)
(f[i] += C[cnt[0]][j] * S[j][i] % mod * fac[cnt[0] - j + cnt[2]] % mod *
ifac[cnt[2]]) %= mod;
for (int i = cnt[0]; i >= 0; i--)
for (int j = i + 1; j <= cnt[0]; j++)
f[i] = (f[i] - C[j][i] * f[j] % mod + mod) % mod;
for (int i = 0; i <= cnt[1]; i++)
for (int j = i; j <= cnt[1]; j++)
(g[i] += C[cnt[1]][j] * S[j][i] % mod * fac[cnt[1] - j + cnt[2]] % mod *
ifac[cnt[2]]) %= mod;
for (int i = cnt[1]; i >= 0; i--)
for (int j = i + 1; j <= cnt[1]; j++)
g[i] = (g[i] - C[j][i] * g[j] % mod + mod) % mod;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++) (h[i] += f[j] * g[i - j]) %= mod;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
(ans[i] += h[j] * S[cnt[2]][i - j] % mod * fac[cnt[2]]) %= mod;
for (int i = n; i >= 1; i--)
if (i >= cir)
ans[i] = ans[i - cir];
else
ans[i] = 0;
for (int i = n; i >= 1; i--) cout << ans[i] << " ";
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3;
int rows[N + 5];
int cols[N + 5];
int tab[N + 5][N + 5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> tab[i][j];
}
}
for (int i = 1; i <= max(n, m); i++) {
rows[i] = i;
cols[i] = i;
}
char op;
int a, b;
while (k--) {
cin >> op >> a >> b;
if (op == 'c') {
swap(cols[a], cols[b]);
}
if (op == 'r') {
swap(rows[a], rows[b]);
}
if (op == 'g') {
cout << tab[rows[a]][cols[b]] << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int M, K, A[6], E[6], T[6][7], P[7], ans = 1e9;
int mat[6][6] = {0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0,
1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1};
char path[7][9] = {"aaab", "aaba", "abaa", "baaa", "aabb", "abab", "abba"},
O[4][600005];
inline void row_swap(int a, int b) {
int i;
for (i = 0; i < 7; i++) swap(T[a][i], T[b][i]);
}
void print() {}
bool proc() {
int i, j, k, v;
for (i = 0; i < 6; i++) {
if (!T[i][i]) {
for (j = i; j < 6; j++)
if (T[j][i]) {
print();
row_swap(i, j);
break;
}
}
if (!T[i][i]) return 0;
print();
v = T[i][i];
for (j = 0; j < 7; j++) {
if (T[i][j] % v != 0) return 0;
T[i][j] /= v;
}
for (j = 0; j < 6; j++)
if (i != j && T[j][i]) {
print();
v = T[j][i];
for (k = 0; k < 7; k++) T[j][k] -= v * T[i][k];
}
print();
}
for (i = 0; i < 6; i++)
if (T[i][6] < 0) return 0;
return 1;
}
int main() {
int i, j, k;
for (i = 0; i < 6; i++) scanf("%d", A + i);
M = A[2];
if (M > A[4]) M = A[4];
if (M > A[5]) M = A[5];
for (i = 0; i <= M; i++) {
for (j = 0; j < 6; j++)
for (k = 0; k < 6; k++) T[j][k] = mat[j][k];
for (j = 0; j < 6; j++) T[j][6] = A[j];
T[2][6] -= i, T[4][6] -= i, T[5][6] -= i;
if (!proc()) continue;
k = i;
for (j = 0; j < 6; j++) k += T[j][6];
if (ans > k) {
ans = k;
P[0] = i;
for (j = 1; j < 7; j++) P[j] = T[j - 1][6];
}
}
if (ans == 1e9) {
puts("-1");
return 0;
}
printf("%d\n", ans);
for (i = 0; i < 7; i++) {
while (P[i]--) {
for (j = 0; j < 4; j++) O[j][K] = path[i][j];
K++;
}
}
for (i = 0; i < 4; i++) puts(O[i]);
}
| 16 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[100];
int tmp[100];
int i;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int j, k;
int max = 0;
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
for (k = 0; k < n; k++) {
tmp[k] = a[k];
}
int counter = 0;
for (k = i; k <= j; k++) {
tmp[k] = 1 - tmp[k];
}
for (k = 0; k < n; k++) {
if (tmp[k] == 1) counter++;
}
if (counter > max) max = counter;
}
}
printf("%d\n", max);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 123;
signed main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int mn = INF, sum = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int x;
cin >> x;
if (x < 0) {
x = -x;
++cnt;
}
mn = std::min(mn, x);
sum += x;
}
}
if (cnt & 1) {
cout << sum - 2 * mn << "\n";
} else {
cout << sum << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double p[205];
int b[205];
double f[205][205][205 * 2];
int main() {
int n, l, k, K;
while (cin >> n >> l >> K) {
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i] /= 100;
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
f[0][0][200 + K] = 1;
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < n + 1; j++) {
for (int k = 0; k < 401; k++) {
if (f[i][j][k] > -0.0000001) {
if (i == n) continue;
f[i + 1][j + 1][min(400, k + b[i])] += f[i][j][k] * p[i];
f[i + 1][j][k] += f[i][j][k] * (1 - p[i]);
}
}
}
}
double ans = 0;
for (int i = 200; i <= 400; i++) {
for (int j = l; j <= n; j++) ans += f[n][j][i];
}
cout << ans << endl;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime[4050];
vector<int> prime;
void find_prime() {
for (int i = 2; i <= 4000; i++) {
if (!is_prime[i]) prime.push_back(i);
for (int j = 0; j < prime.size() && i * prime[j] <= 4000; j++) {
is_prime[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
}
int s[300050];
map<int, int> cnt;
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
find_prime();
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < prime.size(); j++) {
if (s[i] % prime[j] == 0) {
long long sum = 1;
while (s[i] % prime[j] == 0)
s[i] /= prime[j], sum *= prime[j], cnt[sum]++;
}
}
if (s[i] != 1) cnt[s[i]]++;
}
map<int, int>::iterator it;
int maxn = 0;
for (it = cnt.begin(); it != cnt.end(); it++) {
if (it->second != n) {
maxn = max(maxn, it->second);
}
}
if (maxn == 0)
cout << -1 << endl;
else
cout << n - maxn << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9;
int n, m;
long long a[200100], fibo[200100], sumfibo[200100];
struct Segment_Tree {
int left, right, len;
long long s0, s1;
} tree[200100 << 2];
struct Data {
long long a[2][2];
} bb[200100], one, b;
Data operator*(const Data x, const Data y) {
Data res;
res.a[0][0] =
(x.a[0][0] * y.a[0][0] % mod + x.a[0][1] * y.a[1][0] % mod) % mod;
res.a[0][1] =
(x.a[0][0] * y.a[0][1] % mod + x.a[0][1] * y.a[1][1] % mod) % mod;
res.a[1][0] =
(x.a[1][0] * y.a[0][0] % mod + x.a[1][1] * y.a[1][0] % mod) % mod;
res.a[1][1] =
(x.a[1][0] * y.a[0][1] % mod + x.a[1][1] * y.a[1][1] % mod) % mod;
return res;
}
long long cal_fx(long long s0, long long s1, int l) {
long long res;
res = (bb[l - 1].a[0][0] * s1 % mod + bb[l - 1].a[0][1] * s0 % mod) % mod;
return res;
}
void plant_tree(int id, int l, int r) {
tree[id].left = l, tree[id].right = r;
tree[id].len = r - l + 1;
if (l == r) {
tree[id].s0 = fibo[0] * a[l] % mod;
tree[id].s1 = fibo[1] * a[l] % mod;
return;
}
int mid = (l + r) >> 1;
plant_tree(id << 1, l, mid);
plant_tree(id << 1 | 1, mid + 1, r);
tree[id].s0 =
(tree[id << 1].s0 +
cal_fx(tree[id << 1 | 1].s0, tree[id << 1 | 1].s1, tree[id << 1].len)) %
mod;
tree[id].s1 =
(tree[id << 1].s1 + cal_fx(tree[id << 1 | 1].s0, tree[id << 1 | 1].s1,
tree[id << 1].len + 1)) %
mod;
}
void push_down() {}
void update_pos(int id, int pos, long long val) {
if (tree[id].left == tree[id].right) {
tree[id].s0 = fibo[0] * val % mod;
tree[id].s1 = fibo[1] * val % mod;
return;
}
int mid = (tree[id].left + tree[id].right) >> 1;
if (pos <= mid)
update_pos(id << 1, pos, val);
else
update_pos(id << 1 | 1, pos, val);
tree[id].s0 =
(tree[id << 1].s0 +
cal_fx(tree[id << 1 | 1].s0, tree[id << 1 | 1].s1, tree[id << 1].len)) %
mod;
tree[id].s1 =
(tree[id << 1].s1 + cal_fx(tree[id << 1 | 1].s0, tree[id << 1 | 1].s1,
tree[id << 1].len + 1)) %
mod;
}
Segment_Tree query(int id, int l, int r) {
if (tree[id].left == l && tree[id].right == r) {
return tree[id];
}
int mid = (tree[id].left + tree[id].right) >> 1;
if (r <= mid)
return query(id << 1, l, r);
else if (mid < l)
return query(id << 1 | 1, l, r);
else {
Segment_Tree leftson, rightson, now;
leftson = query(id << 1, l, mid);
rightson = query(id << 1 | 1, mid + 1, r);
now.s0 = (leftson.s0 + cal_fx(rightson.s0, rightson.s1, leftson.len)) % mod;
now.s1 =
(leftson.s1 + cal_fx(rightson.s0, rightson.s1, leftson.len + 1)) % mod;
now.len = leftson.len + rightson.len;
return now;
}
}
int main() {
fibo[0] = fibo[1] = 1;
for (int i = 2; i < 200100; i++) {
fibo[i] = (fibo[i - 2] + fibo[i - 1]) % mod;
}
sumfibo[0] = fibo[0];
for (int i = 1; i < 200100; i++) {
sumfibo[i] = (sumfibo[i - 1] + fibo[i]) % mod;
}
one.a[0][0] = one.a[1][1] = 1;
one.a[1][0] = one.a[0][1] = 0;
b.a[0][0] = b.a[0][1] = b.a[1][0] = 1;
b.a[1][1] = 0;
bb[0] = one;
for (int i = 1; i < 200100; i++) {
bb[i] = bb[i - 1] * b;
}
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
plant_tree(1, 1, n);
while (m--) {
int type;
scanf("%d", &type);
if (type == 1) {
int x, v;
scanf("%d %d", &x, &v);
update_pos(1, x, v);
} else if (type == 2) {
int l, r;
scanf("%d %d", &l, &r);
Segment_Tree res = query(1, l, r);
printf("%lld\n", res.s0);
} else if (type == 3) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
}
}
}
| 15 |
#include <bits/stdc++.h>
inline int cmp(double x, double y = 0, double tol = 1e-9) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
char *seq;
int state, ans, n;
int next[155][3];
int dp[155][52][52][52];
int main() {
scanf("%d", &n);
seq = new char[n + 1];
for (int i = 1; i <= n; ++i) {
scanf(" %c", &seq[i]);
seq[i] -= 'a';
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= 2; ++j) next[i][j] = next[i + 1][j];
next[i][seq[i]] = i;
}
delete[] seq;
int m = (n + 2) / 3;
dp[1][0][0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int x = 0; x <= m; ++x)
for (int y = 0; y <= m; ++y)
for (int z = 0; z <= m; ++z)
if (state = dp[i][x][y][z]) {
if (x + y + z == n && ((x - z) < 0 ? -(x - z) : (x - z)) < 2 &&
((x - y) < 0 ? -(x - y) : (x - y)) < 2 &&
((y - z) < 0 ? -(y - z) : (y - z)) < 2)
(ans = (ans + state) % 51123987);
(dp[next[i][0]][x + 1][y][z] =
(dp[next[i][0]][x + 1][y][z] + state) % 51123987);
(dp[next[i][1]][x][y + 1][z] =
(dp[next[i][1]][x][y + 1][z] + state) % 51123987);
(dp[next[i][2]][x][y][z + 1] =
(dp[next[i][2]][x][y][z + 1] + state) % 51123987);
}
printf("%d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, dif, odd, neg;
int a[MAXN];
int cnt[MAXN];
long long ans;
void add(int p, int v) {
odd -= cnt[p] & 1;
neg -= cnt[p] < 0;
cnt[p] += v;
odd += cnt[p] & 1;
neg += cnt[p] < 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, j = n; i < j; i++, j--)
if (a[i] != a[j]) dif++;
for (int i = 1, j = 1; i <= n; i++) {
if (n - i + 1 > i) {
if (a[i] != a[n - i + 1]) dif--;
add(a[i], 1);
add(a[n - i + 1], -1);
} else if (i == n - i + 1)
add(a[i], 1);
else if (n - i + 1 >= j)
add(a[i], 2);
else {
if (a[i] != a[n - i + 1]) dif--;
add(a[i], 1);
add(a[n - i + 1], -1);
}
while (j <= i && !dif && odd <= 1 && !neg) {
if (n - j + 1 < j) {
if (a[j] != a[n - j + 1]) dif++;
add(a[n - j + 1], 1);
add(a[j], -1);
} else if (j == n - j + 1)
add(a[j], -1);
else if (n - j + 1 <= i)
add(a[j], -2);
else {
if (a[j] != a[n - j + 1]) dif++;
add(a[n - j + 1], 1);
add(a[j], -1);
}
j++;
}
ans += j - 1;
}
printf("%lld\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
int main() {
cin >> n;
if (n == 1)
cout << "1";
else {
if (n % 2 == 0) {
n = n - (n / 2 - 1);
cout << n;
} else {
n = n - 1;
n = n - (n / 2 - 1);
cout << n;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5100;
const long long inf = 1e18;
long long s[N], a[N], b[N], c[N], d[N];
long long ans[N], tot;
long long sol(int i, int j) {
if (j < i)
return abs(s[i] - s[j]) + c[i] + b[j];
else
return abs(s[i] - s[j]) + d[i] + a[j];
}
int main() {
int n, ss, e;
while (~scanf("%d%d%d", &n, &ss, &e)) {
int tot = 0;
ans[tot++] = ss;
for (int i = 1; i <= n; i++) scanf("%I64d", &s[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &b[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &c[i]);
for (int i = 1; i <= n; i++) scanf("%I64d", &d[i]);
long long sum = sol(ss, e);
for (int i = 1; i <= n; i++) {
if (i == ss || i == e) continue;
long long tmp = inf;
int id = 0;
ans[tot] = e;
for (int j = 0; j < tot; j++) {
if (sum - sol(ans[j], ans[j + 1]) + sol(ans[j], i) +
sol(i, ans[j + 1]) <
tmp) {
id = j;
tmp = sum - sol(ans[j], ans[j + 1]) + sol(ans[j], i) +
sol(i, ans[j + 1]);
}
}
for (int j = tot - 1; j >= id + 1; j--) ans[j + 1] = ans[j];
ans[id + 1] = i;
tot++;
}
sum = 0;
ans[tot] = e;
for (int i = 0; i < tot; i++) {
sum += sol(ans[i], ans[i + 1]);
}
printf("%I64d\n", sum);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
struct Trie {
Trie() : Children(2) {}
void Add(unsigned int x, int depth) {
unsigned int key = (x >> depth) & 1;
Children[key].second++;
if (depth == 0) return;
if (!Children[key].first) {
Children[key].first.reset(new Trie());
}
Children[key].first->Add(x, depth - 1);
}
void Delete(unsigned int x, int depth) {
unsigned int key = (x >> depth) & 1;
if (--Children[key].second == 0) {
Children[key].first.reset(nullptr);
} else if (depth > 0) {
Children[key].first->Delete(x, depth - 1);
}
}
size_t FindMax(unsigned int x, int depth) {
unsigned int key = (x >> depth) & 1;
size_t nextKey = Children[key ^ 1].second ? (key ^ 1) : key;
size_t res = (nextKey ^ key) << depth;
if (depth) {
size_t m = Children[nextKey].first->FindMax(x, depth - 1);
res |= m;
}
return res;
}
vector<std::pair<std::unique_ptr<Trie>, int>> Children;
};
int main() {
unsigned int n;
cin >> n;
Trie trie;
trie.Add(0, 31);
for (int i = 0; i < n; ++i) {
unsigned int x;
char c;
cin >> c >> x;
if (c == '+') {
trie.Add(x, 31);
} else if (c == '-') {
trie.Delete(x, 31);
} else {
printf("%lu\n", trie.FindMax(x, 31));
}
}
return 0;
}
| 10 |
#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 = 6000 + 19;
const int M = 6000 + 19;
struct edge {
int x, y;
} e[M], E[M];
int pa[N][200 + 19], pb[N][200 + 19];
int ta[N], tb[N], da[N], db[N], da2[N], db2[N], col[N];
int na, nb, m, k, ca, cb, ans, x, y;
map<pair<int, int>, int> A;
void dfs1(int, int, int);
void dfs2(int y, int ca, int cb) {
int x = pb[y][ca];
if (!x) {
return;
} else {
pa[x][ca] = 0;
pb[y][ca] = 0;
dfs1(x, ca, cb);
pa[x][cb] = y;
pb[y][cb] = x;
}
}
void dfs1(int x, int ca, int cb) {
int y = pa[x][cb];
if (!y) {
return;
} else {
pa[x][cb] = 0;
pb[y][cb] = 0;
dfs2(y, ca, cb);
pa[x][ca] = y;
pb[y][ca] = x;
}
}
int main() {
na = IN(), nb = IN(), m = IN(), k = IN();
for (int i = 0; i < m; i++) {
x = IN(), y = IN();
e[i] = (edge){x, y};
da[x]++;
db[y]++;
if (!ta[x] || da2[ta[x]] == k) ta[x] = ++ca;
if (!tb[y] || db2[tb[y]] == k) tb[y] = ++cb;
E[i] = (edge){ta[x], tb[y]};
A[make_pair(ta[x], tb[y])] = i;
da2[ta[x]]++;
db2[tb[y]]++;
fprintf(stderr, "%d %d\n", ta[x], tb[y]);
}
for (int i = 1; i < na + 1; i++)
if (da[i] % k != 0) ans++;
for (int i = 1; i < nb + 1; i++)
if (db[i] % k != 0) ans++;
for (int w = 0; w < m; w++) {
int ca = -1, cb = -1;
x = E[w].x, y = E[w].y;
for (int i = 0; i < k; i++)
if (!pa[x][i]) {
ca = i;
break;
}
for (int i = 0; i < k; i++)
if (!pb[y][i]) {
cb = i;
break;
}
assert(ca != -1 && cb != -1);
if (ca == cb) {
pa[x][ca] = y;
pb[y][cb] = x;
} else {
if (ca < cb) {
dfs2(y, ca, cb);
pa[x][ca] = y;
pb[y][ca] = x;
} else {
dfs1(x, ca, cb);
pa[x][cb] = y;
pb[y][cb] = x;
}
}
}
memset(col, -1, sizeof(col));
for (int i = 1; i < ca + 1; i++) {
for (int j = 0; j < k; j++)
if (pa[i][j]) {
col[A[make_pair(i, pa[i][j])]] = j;
}
}
printf("%d\n", ans);
for (int i = 0; i < m; i++) printf("%d ", col[i] + 1);
puts("");
}
| 22 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long int gcd(long long int a, long long int b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
int main() {
long long int n, k;
cin >> n >> k;
vector<long long int> l(n + 1), r(n + 1), a(n + 1);
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i] >> a[i];
vector<long long int> dp(n + 1, (long long int)(1e18));
dp[1] = 0;
long long int ans = (long long int)(1e18);
for (int i = 1; i <= n; i++) {
if (dp[i] == (long long int)(1e18)) continue;
long long int tot = dp[i];
long long int cur = k;
for (int j = i; j <= n; j++) {
long long int reload = (max(a[j] - cur, 0LL) + k - 1) / k;
if (reload > r[j] - l[j]) break;
tot += a[j];
cur = cur + reload * k - a[j];
if (j == n) {
ans = min(ans, tot);
} else if (l[j + 1] > reload + l[j]) {
dp[j + 1] = min(dp[j + 1], tot + cur);
}
}
}
if (ans == (long long int)(1e18))
cout << -1;
else
cout << ans;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
const int INF = 1e9;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 5, MO = 350, SQ = 550;
int n, q, A[N], QL[N], QR[N], P[N], T[N], C[N], K[N], Q[N];
vector<int> B, X, Y;
bool CMP(int i, int j) {
if (QL[i] / MO != QL[j] / MO) return QL[i] < QL[j];
return (QL[i] / MO) % 2 ? QR[i] > QR[j] : QR[i] < QR[j];
}
void Update(int x, int y) { T[C[x]]--, C[x] += y, T[C[x]]++; }
void Insert(int x, int y) {
if (x >= SQ && !K[x]) Y.push_back(x);
K[x] += y;
}
int Huf() {
X.clear(), Y.clear();
for (int i : B)
if (C[i] >= SQ) X.push_back(C[i]), K[C[i]]++;
sort(X.begin(), X.end());
int huf = 0, c = 0, x = 0, y = 0;
for (int i = 1; i < SQ; i++)
if (K[i] + T[i]) {
K[i] += T[i];
if (c) huf += i + c, K[i]--, Insert(i + c, 1), c = 0;
if (K[i] & 1) c = i, K[i]--;
if (K[i]) huf += i * K[i], Insert(i + i, K[i] >> 1), K[i] = 0;
}
while (x < (int)(X.size()) || y < (int)(Y.size())) {
while (x + 1 < (int)(X.size()) && X[x + 1] == X[x]) x++;
while (y + 1 < (int)(Y.size()) && Y[y + 1] == Y[y]) y++;
int i = 0;
if (x == (int)(X.size()))
i = Y[y++];
else if (y == (int)(Y.size()))
i = X[x++];
else if (X[x] < Y[y])
i = X[x++];
else
i = Y[y++];
if (c) huf += i + c, K[i]--, Insert(i + c, 1), c = 0;
if (K[i] & 1) c = i, K[i]--;
if (K[i]) huf += i * K[i], Insert(i + i, K[i] >> 1), K[i] = 0;
}
return huf;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
mt19937 Rnd(time(0));
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i], C[A[i]]++;
for (int i = 0; i < N; i++)
if (C[i] >= SQ) B.push_back(i);
for (int i = 0; i < n; i++) C[A[i]]--;
cin >> q;
for (int i = 0; i < q; i++) cin >> QL[i] >> QR[i], QL[i]--, P[i] = i;
sort(P, P + q, CMP);
int L = 0, R = 0;
for (int i = 0; i < q; i++) {
int l = QL[P[i]], r = QR[P[i]];
while (l < L) Update(A[--L], +1);
while (R < r) Update(A[R++], +1);
while (L < l) Update(A[L++], -1);
while (r < R) Update(A[--R], -1);
Q[P[i]] = Huf();
}
for (int i = 0; i < q; i++) cout << Q[i] << endl;
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a < b)
gcd(b, a);
else if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
while (n--) {
long long p, q, b;
cin >> p >> q >> b;
long long gcd_pq = gcd(p, q);
p /= gcd_pq;
q /= gcd_pq;
while (q > 1) {
long long res = gcd(q, b);
if (res == 1) break;
while (q % res == 0) q /= res;
b = res;
}
if (q == 1) {
cout << "Finite" << endl;
} else {
cout << "Infinite" << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[n + 5][n + 5];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> a[i][j];
long long k = 0;
for (int i = 2; i < n; i++) {
for (int j = 2; j < n; j++) {
if (a[i - 1][j - 1] == 'X' && a[i - 1][j + 1] == 'X' &&
a[i + 1][j - 1] == 'X' && a[i + 1][j + 1] == 'X' && a[i][j] == 'X')
k++;
}
}
cout << k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, y;
int main() {
cin >> x >> y;
long long r1 = (long long)sqrt(x * x + y * y);
if (r1 * r1 != (x * x + y * y))
r1++;
else {
cout << "black" << endl;
return 0;
}
if (x == 0 || y == 0) {
cout << "black" << endl;
return 0;
}
if ((x > 0 && y > 0) || (x < 0 && y < 0)) {
if (r1 % 2 == 0)
cout << "white" << endl;
else
cout << "black" << endl;
} else {
if (r1 % 2)
cout << "white" << endl;
else
cout << "black" << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, a[10];
long long dp[300][10], ncr[101][101];
void pre() {
for (int i = 0; i < 101; i++) {
ncr[i][0] = 1;
ncr[i][i] = 1;
for (int j = 1; j < i; j++) {
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % MOD;
}
}
}
long long rec(int len, int digit) {
long long &ans = dp[len][digit];
if (ans != -1) return ans;
if (digit == 9) return (len >= a[9]);
ans = 0;
for (int cnt = a[digit]; cnt <= len; cnt++) {
ans = (ans + (rec(len - cnt, digit + 1) *
(digit > 0 ? ncr[len][cnt] : ncr[len - 1][cnt])) %
MOD) %
MOD;
}
return ans;
}
int main() {
int sum = 0;
scanf("%d", &n);
for (int i = 0; i < 10; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum == a[0]) sum++;
pre();
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (int len = sum; len <= n; len++) {
ans += rec(len, 0);
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int A, B, Px, Py, Qx, Qy;
void process() {
int t1, t2, t3, t4;
t1 = (Px + Py) / (A * 2);
if (Px + Py < 0) t1--;
t2 = (Qx + Qy) / (A * 2);
if (Qx + Qy < 0) t2--;
t3 = (Px - Py) / (B * 2);
if (Px - Py < 0) t3--;
t4 = (Qx - Qy) / (B * 2);
if (Qx - Qy < 0) t4--;
cout << max(abs(t1 - t2), abs(t3 - t4));
}
int main() {
scanf("%d%d%d%d%d%d", &A, &B, &Px, &Py, &Qx, &Qy);
process();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int p[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
vector<int> ans;
int main() {
int n, k;
cin >> n;
k = 2 * n * n;
ans.push_back(1);
for (int i = 0; ans.size() < n; ++i) {
for (int j = 0; j < ans.size(); ++j) {
if (p[i] * ans[j] <= k) {
ans.push_back(p[i] * ans[j]);
}
}
}
sort(ans.rbegin(), ans.rend());
for (int i = 0; i < n; ++i) {
cout << ans[i] << ' ';
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-8;
const int INF = 1000000001;
int _gt(int n, int x, int y) {
if (y == 0) return x;
if (x == n) return y + n;
if (y == n) return 3 * n - x;
if (x == 0) return 4 * n - y;
}
int main() {
int n, x1, y1, x2, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
int a1 = _gt(n, x1, y1);
int a2 = _gt(n, x2, y2);
cout << min(abs(a2 - a1), 4 * n - max(a2, a1) + min(a1, a2));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, z;
string str;
int main() {
cin >> n >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'L') x--;
if (str[i] == 'R') y++;
}
x *= -1;
z = (x + y) + 1;
cout << z;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, h, t;
cin >> n >> m >> h >> t;
vector<vector<int>> ad(n);
vector<pair<int, int>> edge(m * 2);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
if (ad[a].size() < 202) ad[a].push_back(b);
if (ad[b].size() < 202) ad[b].push_back(a);
edge[2 * i] = make_pair(a, b);
edge[2 * i + 1] = make_pair(b, a);
}
vector<bool> table(n);
for (int i = 0; i < m * 2; i++) {
int aa = 0, bb = 0, cc = 0;
int a = edge[i].first, b = edge[i].second;
aa = ad[a].size() - 1, bb = ad[b].size() - 1;
if (aa < h || bb < t) continue;
for (int ch : ad[b]) {
table[ch] = true;
}
for (int ch : ad[a]) {
if (table[ch]) cc++;
}
for (int ch : ad[b]) {
table[ch] = false;
}
aa -= cc, bb -= cc;
int dd = 0;
if (aa < h) {
if ((h - aa) > cc) continue;
cc -= h - aa;
dd += h - aa;
}
if ((bb + cc) < t) continue;
cout << "YES\n";
cout << a + 1 << " " << b + 1 << "\n";
for (int ch : ad[b]) {
table[ch] = true;
}
int count = 0;
int ccc = 0;
for (int ch : ad[a]) {
if (ch == b) continue;
if (table[ch]) {
if (dd <= ccc) continue;
ccc++;
table[ch] = false;
}
cout << ch + 1 << " ";
count++;
if (count == h) break;
}
cout << "\n";
count = 0;
for (int ch : ad[b]) {
if (ch == a || !table[ch]) continue;
cout << ch + 1 << " ";
count++;
if (count == t) break;
}
cout << "\n";
return 0;
}
cout << "NO\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'U')
y++;
else if (s[i] == 'D')
y--;
else if (s[i] == 'L')
x--;
else
x++;
}
int val = abs(x) + abs(y);
cout << n - val;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int ar[100006], s[100006];
int n, i, k;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
s[0] = ar[0];
int p = 1;
for (i = 1; i < n; i++)
if (ar[i] != ar[i - 1]) {
s[p] = ar[i];
p++;
}
int end = p;
int diff = 0;
p = 0;
while (k--) {
while (s[p] == 0 && p != end) {
p++;
if (p == end) break;
}
if (p == end) {
cout << "0" << '\n';
continue;
}
cout << s[p] - diff << '\n';
diff = s[p];
p++;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k;
vector<int> vec;
vector<int>::iterator it;
map<int, int> mp;
map<int, int>::iterator it2;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
mp[k]++;
}
while (1) {
bool chk = false;
for (it2 = mp.begin(); it2 != mp.end(); it2++) {
if (it2->second > 0) {
chk = true;
break;
}
}
if (!chk) break;
for (it2 = mp.begin(); it2 != mp.end(); it2++) {
if (it2->second != 0) {
k = it2->first;
vec.push_back(k);
mp[k]--;
}
}
}
int cnt = 0;
for (i = 0; i < vec.size() - 1; i++) {
if (vec[i] < vec[i + 1]) cnt++;
}
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char inp[100005];
int f1[100005][2];
int f2[100005][2];
int flip[100005][2];
int main() {
int n;
int ans = 0;
scanf("%d", &n);
scanf("%s", inp);
memset(f1, 0, sizeof f1);
memset(f2, 0, sizeof f2);
memset(flip, 0, sizeof flip);
if (inp[0] == '0')
f1[0][0] = 1, f1[0][1] = 0;
else
f1[0][0] = 0, f1[0][1] = 1;
for (int i = 1; i <= n - 1; i++) {
if (inp[i] == '0') f1[i][0] = f1[i - 1][1] + 1, f1[i][1] = f1[i - 1][1];
if (inp[i] == '1') f1[i][0] = f1[i - 1][0], f1[i][1] = f1[i - 1][0] + 1;
f1[i][0] = max(f1[i - 1][0], f1[i][0]);
f1[i][1] = max(f1[i - 1][1], f1[i][1]);
}
if (inp[n - 1] == '0')
f2[n - 1][0] = 1, f2[n - 1][1] = 0;
else
f2[n - 1][0] = 0, f2[n - 1][1] = 1;
for (int i = n - 2; i >= 0; i--) {
if (inp[i] == '0') f2[i][0] = f2[i + 1][1] + 1, f2[i][1] = f2[i + 1][1];
if (inp[i] == '1') f2[i][0] = f2[i + 1][0], f2[i][1] = f2[i + 1][0] + 1;
f2[i][0] = max(f2[i + 1][0], f2[i][0]);
f2[i][1] = max(f2[i + 1][1], f2[i][1]);
}
if (inp[n - 1] == '0') flip[n - 1][0] = 0, flip[n - 1][1] = 1;
if (inp[n - 1] == '1') flip[n - 1][0] = 1, flip[n - 1][1] = 0;
ans = 1;
if (n - 2 > 0) ans = max(ans, flip[n - 1][0] + f1[n - 2][1]);
if (n - 2 > 0) ans = max(ans, flip[n - 1][1] + f1[n - 2][0]);
for (int i = n - 2; i >= 0; i--) {
flip[i][0] = f2[i + 1][0];
if (inp[i] == '1') flip[i][0] = max(flip[i][0], f2[i + 1][1] + 1);
flip[i][0] = max(flip[i][0], flip[i + 1][0]);
if (inp[i] == '1') flip[i][0] = max(flip[i][0], flip[i + 1][1] + 1);
flip[i][1] = f2[i + 1][1];
if (inp[i] == '0') flip[i][1] = max(flip[i][1], f2[i + 1][0] + 1);
flip[i][1] = max(flip[i][1], flip[i + 1][1]);
if (inp[i] == '0') flip[i][1] = max(flip[i][1], flip[i + 1][0] + 1);
ans = max(ans, flip[i][0]);
if (i > 0) ans = max(ans, flip[i][0] + f1[i - 1][1]);
ans = max(ans, flip[i][1]);
if (i > 0) ans = max(ans, flip[i][1] + f1[i - 1][0]);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int main() {
int n;
cin >> n;
vector<vector<int>> dp(26, vector<int>(26, -INF));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int m = s.size();
for (int j = 0; j < 26; j++) {
dp[j][s[m - 1] - 'a'] = max(dp[j][s[m - 1] - 'a'], dp[j][s[0] - 'a'] + m);
}
dp[s[0] - 'a'][s[m - 1] - 'a'] = max(dp[s[0] - 'a'][s[m - 1] - 'a'], m);
}
int ans = 0;
for (int i = 0; i < 26; i++) ans = max(ans, dp[i][i]);
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double pii = acos(-1.0);
const int maxn = 100000007;
const double eps = 1e-6;
const long long int Inf = 1LL << 62;
const long long int mod = pow(2, 32);
const long long int pnum = 5761460;
void solve_with_case(int cas) {}
const int arr_len = 400005;
int arr[arr_len];
int n, q;
long long int vis[arr_len][3];
long long int dp(int index, int nei) {
if (index >= n) return 0;
if (vis[index][nei] != -1) return vis[index][nei];
long long int p, q;
if (nei == 1) {
p = dp(index + 1, 1);
q = dp(index + 1, 0) - arr[index];
return vis[index][nei] = max(p, q);
} else {
p = dp(index + 1, 0);
q = dp(index + 1, 1) + arr[index];
return vis[index][nei] = max(p, q);
}
}
void solve_without_case() {
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> arr[i];
memset(vis, -1, sizeof(vis));
cout << dp(0, 0) << "\n";
}
int main() {
int t, cas = 0;
cin >> t;
while (t--) {
solve_without_case();
cas++;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-5;
const int MAXN = 1005;
int n, m, tt;
int vis[MAXN], vis2[MAXN];
int a[MAXN];
int main() {
int i, j, k, ca = 1;
while (scanf("%d", &n) != EOF) {
memset(vis, 0, sizeof(vis));
int ans = 0;
for (i = 0; i < n; i++) {
scanf("%d", a + i);
}
int sum = 0;
while (1) {
for (i = 0; i < n; i++) {
if (!vis[i]) {
if (sum >= a[i]) {
sum++;
vis[i] = 1;
}
}
}
if (sum == n) break;
ans++;
for (i = n - 1; i >= 0; i--) {
if (!vis[i]) {
if (sum >= a[i]) {
sum++;
vis[i] = 1;
}
}
}
if (sum == n) break;
ans++;
}
printf("%d\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int N = 2e5 + 5;
int n, ans[N];
long long bit[N], p[N];
void up(int i, int val) {
assert(i > 0);
for (; i <= n; i += i & -i) bit[i] += val;
}
long long get(int i) {
long long res = 0;
for (; i; i -= i & -i) res += bit[i];
return res;
}
inline void sol() {
cin >> n;
for (int i = 0, _ = (n); i < _; i++) cin >> p[i], up(i + 1, i + 1);
for (int i = (int)(n)-1; i >= 0; --i) {
int l = 1, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (get(mid - 1) <= p[i])
l = mid;
else
r = mid - 1;
}
up(l, -l);
ans[i] = l;
}
for (int i = 0, _ = (n); i < _; i++) cout << ans[i] << ' ';
}
signed main() {
{ ios_base::sync_with_stdio(false), cin.tie(NULL); };
cout.precision(10);
cout << fixed;
sol();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
int val[MAXN];
int tdeath[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", val + i);
tdeath[0] = -1;
vector<int> S(1, 0);
int sol = 0;
for (int i = 1; i < n; ++i) {
tdeath[i] = 0;
while (S.size() > 0 && val[S.back()] < val[i]) {
tdeath[i] = max(tdeath[i], tdeath[S.back()] + 1);
S.pop_back();
}
if (S.size() == 0) tdeath[i] = -1;
S.push_back(i);
sol = max(sol, tdeath[i] + 1);
}
printf("%d\n", sol);
return 0;
}
| 11 |
Subsets and Splits