solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 333;
int n, a[N], c[M][N];
deque<int> Q[M];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) Q[i / M].push_back(a[i]);
for (int i = 0; i < n; i++) c[i / M][a[i]]++;
int q, t, l, r, k, last = 0, L, R, tmp, ans;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &t, &l, &r);
l = (l + last - 1) % n, r = (r + last - 1) % n;
if (l > r) swap(l, r);
if (t == 1) {
L = l / M, R = r / M;
for (int i = R - 1; i >= L; i--) {
tmp = Q[i][M - 1];
Q[i].pop_back();
c[i][tmp]--, c[i + 1][tmp]++;
Q[i + 1].push_front(tmp);
}
if (l == r) continue;
if (L == R) {
tmp = Q[R][r % M];
Q[R].erase(Q[R].begin() + (r % M));
Q[L].insert(Q[L].begin() + (l % M), tmp);
} else {
tmp = Q[R][r % M + 1];
Q[R].erase(Q[R].begin() + r % M + 1);
c[R][tmp]--, c[L][tmp]++;
Q[L].insert(Q[L].begin() + (l % M), tmp);
}
} else {
scanf("%d", &k);
k = (k + last - 1) % n + 1;
ans = 0;
L = l / M, R = r / M;
for (int i = L + 1; i < R; i++) ans += c[i][k];
if (L == R) {
for (int i = l; i <= r; i++) ans += Q[L][i % M] == k;
} else {
for (int i = l; i < L * M + M; i++) ans += Q[L][i % M] == k;
for (int i = R * M; i <= r; i++) ans += Q[R][i % M] == k;
}
printf("%d\n", ans);
last = ans;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int a, b, c, d;
double x, y;
scanf("%d%d%d%d", &a, &b, &c, &d);
x = (a * 1.0 / b);
y = (1 - (a * 1.0 / b)) * (1 - (c * 1.0 / d));
printf("%.12f\n", x * 1.0 / (1 - y));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 0, a;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
if (a == 1) c++;
v.push_back(a);
}
cout << c << endl;
for (int i = 0; i < v.size(); i++) {
if (v[i + 1] == 1) cout << v[i] << " ";
}
cout << v[v.size() - 1] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dr[4] = {1, -1, 0, 0};
int dc[4] = {0, 0, 1, -1};
int s[2];
int main() {
int n, a, b, c;
scanf("%d", &n);
while (n--) {
cin >> a >> b >> c;
a--;
s[a] += b;
s[a] -= c;
}
if (s[0] >= 0)
cout << "LIVE\n";
else
cout << "DEAD\n";
if (s[1] >= 0)
cout << "LIVE\n";
else
cout << "DEAD\n";
return 0;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k, m, c;
char s;
cin >> n >> k;
m = 0;
c = 0;
for (i = 0; i < n; i++) {
cin >> s;
if (s == '#') {
c++;
if (m < c) {
m = c;
}
} else {
c = 0;
}
}
if (m < k) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100001][2];
int main() {
int n;
cin >> n;
long long c[n + 1];
for (int i = 0; i < n; i++) cin >> c[i];
vector<string> v(n + 1);
vector<string> rev(n + 1);
for (int i = 0; i < n; i++) {
cin >> v[i];
rev[i] = v[i];
reverse(rev[i].begin(), rev[i].end());
dp[i][0] = dp[i][1] = 1e17;
}
dp[0][0] = 0;
dp[0][1] = c[0];
for (int i = 1; i < n; i++) {
if (v[i] >= v[i - 1]) dp[i][0] = dp[i - 1][0];
if (v[i] >= rev[i - 1]) dp[i][0] = min(dp[i][0], dp[i - 1][1]);
if (rev[i] >= v[i - 1]) dp[i][1] = dp[i - 1][0] + c[i];
if (rev[i] >= rev[i - 1]) dp[i][1] = min(dp[i][1], dp[i - 1][1] + c[i]);
}
if (min(dp[n - 1][0], dp[n - 1][1]) >= 1e17)
cout << "-1";
else
cout << min(dp[n - 1][0], dp[n - 1][1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const double e = exp(1.0);
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
bool cmpbig(int a, int b) { return a > b; }
bool cmpsmall(int a, int b) { return a < b; }
using namespace std;
char s[100005];
char s2[100005];
int main() {
int siz, h = 0, x1 = 0, x2 = 0;
string s;
cin >> s;
siz = s.size();
for (int i = 0; i < siz; ++i) {
if (s[i] == '(')
++x1, ++x2;
else if (s[i] == ')')
--x1, x2 = (((x2 - 1) >= 0) ? (x2 - 1) : 0);
else
++h, --x1, x2 = 0;
if (x1 < 0) {
cout << -1;
return 0;
}
}
if (x2 > 0) {
cout << -1;
return 0;
}
--h;
for (int i = 0; i < h; ++i) cout << 1 << '\n';
cout << 1 + x1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct SegmentTree {
int N;
vector<T> lazy;
vector<T> stree;
inline T f(T a, T b) { return a + b; }
SegmentTree(int n) {
N = n;
int sz = 1;
while (sz < N) sz <<= 1;
stree.assign(sz << 1, 0);
lazy.assign(sz << 1, 0);
}
void updatePoint(int v, int l, int r, int idx, T val) {
if (l == r) {
stree[v] += val;
return;
}
int mid = (l + r) >> 1;
if (idx <= mid)
updatePoint(v << 1, l, mid, idx, val);
else
updatePoint(v << 1 | 1, mid + 1, r, idx, val);
stree[v] = f(stree[v << 1], stree[v << 1 | 1]);
}
void updatePoint(int idx, T val) { updatePoint(1, 1, N, idx, val); }
void propagate(int v, int l, int mid, int r) {
lazy[v << 1] += lazy[v];
lazy[v << 1 | 1] += lazy[v];
stree[v << 1] += (mid - l + 1) * lazy[v];
stree[v << 1 | 1] += (r - mid) * lazy[v];
lazy[v] = 0;
}
void updateRange(int v, int l, int r, int rangeStart, int rangeEnd, T val) {
if (r < rangeStart || l > rangeEnd) return;
if (l >= rangeStart && r <= rangeEnd) {
stree[v] += (r - l + 1) * val;
lazy[v] += val;
return;
}
int mid = (l + r) >> 1;
propagate(v, l, mid, r);
updateRange(v << 1, l, mid, rangeStart, rangeEnd, val);
updateRange(v << 1 | 1, mid + 1, r, rangeStart, rangeEnd, val);
stree[v] = f(stree[v << 1], stree[v << 1 | 1]);
}
void updateRange(int l, int r, T val) { updateRange(1, 1, N, l, r, val); }
T query(int v, int l, int r, int queryStart, int queryEnd) {
if (r < queryStart || l > queryEnd) return 0;
if (l >= queryStart && r <= queryEnd) return stree[v];
int mid = (l + r) >> 1;
propagate(v, l, mid, r);
T q1 = query(v << 1, l, mid, queryStart, queryEnd);
T q2 = query(v << 1 | 1, mid + 1, r, queryStart, queryEnd);
return f(q1, q2);
}
T query(int l, int r) { return query(1, 1, N, l, r); }
};
int pos(int p, int n, int val) {
if (val == p)
return 1;
else if (val < p)
return val + 1;
return val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
int arr[m];
for (int i = 0; i < m; i++) cin >> arr[i];
SegmentTree<long long> tree(n);
for (int i = 0; i < m - 1; i++) {
int x = arr[i];
int y = arr[i + 1];
if (x == y) continue;
if (x < y) {
if (x > 1) tree.updateRange(1, x - 1, abs(x - y));
tree.updateRange(x, x, abs(1 - y));
if (abs(x - y) > 1) tree.updateRange(x + 1, y - 1, abs((x + 1) - y));
tree.updateRange(y, y, abs((x + 1) - 1));
if (y < n) tree.updateRange(y + 1, n, abs((x + 1) - (y + 1)));
} else {
if (y > 1) tree.updateRange(1, y - 1, abs((x) - (y)));
tree.updateRange(y, y, abs(x - 1));
if (abs(x - y) > 1) tree.updateRange(y + 1, x - 1, abs(x - (y + 1)));
tree.updateRange(x, x, abs(1 - (y + 1)));
if (x < n) tree.updateRange(x + 1, n, abs((x + 1) - (y + 1)));
}
}
for (int i = 1; i <= n; i++) cout << tree.query(i, i) << ' ';
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int total = (s[s.size() - 1] - '0');
for (int i = s.size() - 2; i >= 0; i--) {
if (s[i] == '0') {
continue;
} else {
total += (s[i] - '0') + 1;
}
}
cout << total << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int col[100005];
int n;
vector<int> g[2][100005];
int call;
vector<int> V;
int solve(int i, int c) {
if (col[i] != -1) {
if (col[i] == c)
return 0;
else
return 10000000;
}
col[i] = c;
V.push_back(i);
int res = c;
for (int j = 0; j < g[call][i].size(); j++) {
int u = g[call][i][j];
res += solve(u, c);
if (res > n) return res;
}
for (int j = 0; j < g[1 - call][i].size(); j++) {
int res2 = solve(g[1 - call][i][j], 1 - c);
if (res2 > 1000000) return res2;
res += res2;
}
return res;
}
vector<int> choose;
int solve() {
memset(col, -1, sizeof(col));
int ans = 0;
call = 0;
vector<int> moves;
for (int i = 0; i < n; i++) {
if (col[i] != -1) continue;
V.clear();
int res = solve(i, 0);
int all = V.size();
if (res > n) {
ans = 1000000000;
break;
}
if (res > all - res) {
ans += all - res;
for (int j = 0; j < V.size(); j++)
if (col[V[j]] == 0) moves.push_back(V[j]);
} else {
ans += res;
for (int j = 0; j < V.size(); j++)
if (col[V[j]] == 1) moves.push_back(V[j]);
}
}
memset(col, -1, sizeof(col));
vector<int> moves2;
int ans2 = 0;
call = 1;
for (int i = 0; i < n; i++) {
if (col[i] != -1) continue;
V.clear();
int res = solve(i, 0);
if (res > n) {
ans2 = 1000000000;
break;
}
int all = V.size();
if (res > all - res) {
ans2 += all - res;
for (int j = 0; j < V.size(); j++)
if (col[V[j]] == 0) moves2.push_back(V[j]);
} else {
ans2 += res;
for (int j = 0; j < V.size(); j++)
if (col[V[j]] == 1) moves2.push_back(V[j]);
}
}
if (ans < ans2)
choose = moves;
else
choose = moves2;
return min(ans, ans2);
}
char s[10];
int main() {
int m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d %s", &u, &v, s);
u--;
v--;
if (s[0] == 'R') {
g[0][u].push_back(v);
g[0][v].push_back(u);
} else {
g[1][u].push_back(v);
g[1][v].push_back(u);
}
}
int ans = solve();
if (ans > n)
printf("-1\n");
else {
printf("%d\n", ans);
for (int i = 0; i < choose.size(); i++) printf("%d ", choose[i] + 1);
printf("\n");
}
}
| 7 |
#include <bits/stdc++.h>
int n, x, y;
int main() {
while (scanf("%d%d%d", &n, &x, &y) != EOF) {
if ((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1))
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[2005][3];
int mark[2005];
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &a[i][0], &a[i][1], &a[i][2]);
if (a[i][0]) {
for (int j = a[i][1]; j < a[i][2]; j++) {
mark[j] = 1;
}
}
}
for (int i = 1; i <= m; i++) {
bool ok = false;
if (!a[i][0]) {
for (int j = a[i][1]; j < a[i][2]; j++) {
if (!mark[j]) {
ok = true;
break;
}
}
if (!ok) {
printf("NO\n");
return 0;
}
}
}
int ans = 2000;
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (!mark[i - 1]) ans--;
cout << ans << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
int n, m, l, r, mx, a[maxn];
int dp[maxn][22];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> l >> r;
a[l] = max(a[l], r);
mx = max(mx, r);
}
for (int i = 1; i <= mx; ++i) {
a[i] = max(a[i], a[i - 1]);
}
for (int i = 0; i <= mx; ++i) {
dp[i][0] = a[i];
}
for (int i = 1; i <= 20; ++i) {
for (int j = 0; j <= mx; ++j) {
dp[j][i] = dp[dp[j][i - 1]][i - 1];
}
}
while (m--) {
cin >> l >> r;
int ans = 0;
for (int i = 20; i >= 0; --i) {
if (dp[l][i] < r) {
ans += 1 << i;
l = dp[l][i];
}
}
if (a[l] >= r)
cout << ans + 1 << endl;
else
cout << -1 << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e6 + 100;
long long n, m, k, a[5005][5005];
pair<long long, long long> rows[5005], col[5005];
int main() {
cin >> n >> m >> k;
for (long long i = 1; i <= k; i++) {
long long t, x, y;
cin >> t >> x >> y;
if (t == 1) {
rows[x].first = y;
rows[x].second = i;
}
if (t == 2) {
col[x].first = y;
col[x].second = i;
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (rows[i].second > col[j].second)
cout << rows[i].first << " ";
else
cout << col[j].first << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<int> inT;
set<int>::iterator it;
int ans[300000];
vector<int> pak;
int main() {
int n, m, l, r, x, i;
cin >> n >> m;
for (i = 0; i < n; i++) {
inT.insert(i);
}
for (i = 0; i < m; i++) {
cin >> l >> r >> x;
l--;
r--;
x--;
it = inT.lower_bound(l);
while (it != inT.end()) {
if (*it > r) break;
if (*it != x) {
pak.push_back(*it);
ans[*it] = x + 1;
}
it++;
}
for (x = 0; x < pak.size(); x++) inT.erase(pak[x]);
pak.clear();
}
for (i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
int flag[10010];
for (int i = 1; i < 1001; i++) flag[i] = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i];
flag[arr[i]]++;
}
int len = 0;
int count = 0;
for (int i = 1; i < 1001; i++) {
if (flag[i] != 0) {
count++;
len = max(len, flag[i]);
}
}
cout << len << " " << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Trie {
int nxt[10];
int fre;
int lst, lstc;
};
string names[25];
string lines[25];
Trie tr[10007];
int tot = 1;
int add(string s) {
int len = s.length();
int now = 1;
for (int i = 0; i < len; i++) {
int ch = s[i] - '0';
if (!tr[now].nxt[ch]) {
tr[now].nxt[ch] = ++tot;
tr[tot].lst = now;
tr[tot].lstc = ch;
}
now = tr[now].nxt[ch];
}
if (tr[now].fre == 0) {
int len = s.length();
int now = 1;
for (int i = 0; i < len; i++) {
int ch = s[i] - '0';
if (!tr[now].nxt[ch]) {
tr[now].nxt[ch] = ++tot;
tr[tot].lst = now;
tr[tot].lstc = ch;
} else
now = tr[now].nxt[ch];
tr[now].fre++;
}
return 1;
}
return 0;
}
bool cmp2(string a, string b) { return a.length() > b.length(); }
string outstring(int id) {
string ans("");
stack<char> s;
if (id <= 1) return ans;
while (id != 1) {
s.push(tr[id].lstc);
id = tr[id].lst;
}
while (!s.empty()) {
string ch("0");
ch[0] += s.top();
s.pop();
ans += ch;
}
return ans;
}
void solve(int id) {
memset(tr, 0, sizeof(tr));
tot = 1;
tr[1].fre = 1;
stringstream line(lines[id]);
vector<string> nums;
string a;
while (line >> a) {
reverse(a.begin(), a.end());
nums.push_back(a);
}
sort(nums.begin(), nums.end(), cmp2);
vector<string> whh;
for (int i = 0; i < nums.size(); i++) {
int flag = add(nums[i]);
if (flag) {
reverse(nums[i].begin(), nums[i].end());
whh.push_back(nums[i]);
}
}
cout << whh.size() << " ";
for (int i = 0; i < whh.size(); i++) cout << whh[i] << " ";
cout << endl;
}
int main() {
map<string, int> mp;
int n;
int sum = 1;
cin >> n;
for (int i = 0; i < n; i++) {
string name;
cin >> name;
int wyx;
cin >> wyx;
string buf;
getline(cin, buf);
if (!mp[name]) {
mp[name] = sum++;
int id = mp[name];
names[id] = name;
lines[id] = buf;
} else {
lines[mp[name]] += buf;
}
}
cout << sum - 1 << endl;
for (int i = 1; i < sum; i++) {
cout << names[i] << " ";
solve(i);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
vector<int> calc(vector<pair<int, int>>& pv, int n) {
int maxX = INT_MIN, minX = INT_MAX, maxY = INT_MIN, minY = INT_MAX;
for (auto& p : pv) {
int x = p.first, y = p.second;
maxX = max(maxX, x);
minX = min(minX, x);
maxY = max(maxY, y);
minY = min(minY, y);
}
int ans1 = 2 * (maxX - minX + maxY - minY);
vector<vector<int>> base;
for (int i = 0; i < 3; ++i) {
int a = i;
int b = (i + 1) % 3;
base.emplace_back(vector<int>{a, 1, b, -1});
}
vector<vector<int>> cs;
vector<int> tmp(3, 0);
dfs(0, base, tmp, cs);
int ans0 = 0;
for (auto xs : cs) {
for (auto ys : cs) {
vector<pair<int, int>> xys(3);
xys[0] = make_pair(xs[0], ys[0]);
xys[1] = make_pair(xs[1], ys[1]);
xys[2] = make_pair(xs[2], ys[2]);
ans0 = max(ans0, calc(pv, xys));
}
}
vector<int> res(n - 2);
res[0] = ans0;
for (int i = 4, j = 1; i <= n; ++i, ++j) {
res[j] = ans1;
}
return res;
}
private:
void dfs(int i, vector<vector<int>>& base, vector<int>& tmp,
vector<vector<int>>& res) {
if (i == base.size()) {
res.push_back(tmp);
return;
}
int a = base[i][0], da = base[i][1], b = base[i][2], db = base[i][3];
tmp[a] += da;
tmp[b] += db;
dfs(i + 1, base, tmp, res);
tmp[a] -= da;
tmp[b] -= db;
tmp[a] -= da;
tmp[b] -= db;
dfs(i + 1, base, tmp, res);
tmp[a] += da;
tmp[b] += db;
}
int calc(vector<pair<int, int>>& pv, vector<pair<int, int>>& cs) {
int n = pv.size();
int m = cs.size();
if (n == 0 || m == 0) {
return 0;
}
int res = 0;
const int NINF = INT_MIN / 2;
vector<int> cur(m + 1, NINF);
cur[0] = 0;
vector<int> nxt(m + 1, NINF);
for (int i = 0; i < n; ++i) {
cur[0] = 0;
fill(nxt.begin(), nxt.end(), NINF);
for (int j = 0; j <= i && j < m; ++j) {
int num = pv[i].first * cs[j].first + pv[i].second * cs[j].second;
nxt[j + 1] = max(cur[j + 1], cur[j] + num);
}
swap(cur, nxt);
}
for (auto num : cur) {
res = max(res, num);
}
res = cur[m];
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n;
cin >> n;
vector<pair<int, int>> pv;
pv.reserve(n);
for (int i = 0, x = 0, y = 0; i < n; ++i) {
cin >> x >> y;
pv.emplace_back(x, y);
}
auto res = sol.calc(pv, n);
for (auto r : res) {
cout << r << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353, maxn = 200030;
int aabs(int x) {
if (x < 0) return -x;
return x;
}
long long pow(long long x, long long a) {
long long now = 1;
while (a) {
if (a % 2) now = now * x % mod;
x = x * x % mod;
a >>= 1;
}
return now;
}
int t;
void solve() {
int n, m;
scanf("%d%d", &n, &m);
int a[n];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
vector<pair<int, int> > seg[n + 1];
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
int xh = lower_bound(a, a + n, l) - a;
if (xh < n && a[xh] <= r) continue;
seg[xh].emplace_back(l, r);
}
for (int i = 0; i <= n; i++) {
sort(seg[i].begin(), seg[i].end());
vector<pair<int, int> > temp;
for (auto [l, r] : seg[i]) {
if (!temp.empty() && temp.back().first == l) continue;
while (!temp.empty() && temp.back().second >= r) temp.pop_back();
temp.emplace_back(l, r);
}
seg[i] = temp;
}
for (int i = 0; i < n; i++) {
seg[i].emplace_back(a[i], a[i]);
seg[i + 1].insert(seg[i + 1].begin(), make_pair(a[i], a[i]));
}
long long dp[2];
dp[0] = a[0] - seg[0][0].second;
dp[1] = dp[0] * 2;
for (int i = 1; i < n; i++) {
long long temp[2];
temp[0] = temp[1] = 1e18;
for (int j = 0; j < seg[i].size() - 1; j++) {
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++)
temp[x] =
min(temp[x], dp[y] + (2LL - y) * (seg[i][j].first - a[i - 1]) +
(1LL + x) * (a[i] - seg[i][j + 1].second));
}
dp[0] = temp[0];
dp[1] = temp[1];
}
long long ans = 1e18;
for (int i = 0; i < 2; i++)
ans = min(ans, dp[i] + (seg[n].back().first - a[n - 1]) * (2LL - i));
printf("%lld\n", ans);
return;
}
int main() {
scanf("%d", &t);
int a[t];
while (t--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t1, t2, x1, x2, t0;
int by1 = 0, by2 = 0;
double b = 1e10;
scanf("%d%d%d%d%d", &t1, &t2, &x1, &x2, &t0);
if (t0 == t2) {
printf("%d %d\n", (t0 == t1 ? x1 : 0), x2);
return 0;
}
if (t0 == t1) {
printf("%d %d\n", x1, 0);
return 0;
}
for (int y1 = 0; y1 <= x1; y1++) {
long long y2 = (t0 - t1) * 1LL * y1 / (t2 - t0);
if (y1 == 0) y2 = x2;
y2 = min(y2, 1LL * x2);
y2 = max(y2, 0LL);
double d = ((t1 * 1. * y1 + t2 * 1. * y2) / (y1 + y2)) - t0;
if (d >= 0 && (d < b || (d < b + 1e-9 && by1 + by2 < y1 + y2))) {
b = d;
by1 = y1;
by2 = y2;
}
++y2;
y2 = min(y2, 1LL * x2);
y2 = max(y2, 0LL);
d = ((t1 * 1. * y1 + t2 * 1. * y2) / (y1 + y2)) - t0;
if (d >= 0 && (d < b || (d < b + 1e-9 && by1 + by2 < y1 + y2))) {
b = d;
by1 = y1;
by2 = y2;
}
}
printf("%d %d\n", by1, by2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100001];
int first[510][510];
long long dfs(int l, int r) {
if (l > r) return 1;
if (l == r) return 1;
if (first[l][r]) return first[l][r];
first[l][r] = dfs(l + 1, r);
for (int k = l; k < r; ++k) {
if (a[k + 1] > a[l + 1])
first[l][r] =
(first[l][r] + dfs(l + 1, k) * 1ll * dfs(k, r)) % 1000000007;
}
return first[l][r];
}
int main() {
cin >> n;
for (int k = 1; k <= n; ++k) cin >> a[k];
for (int k = 1; k <= n; ++k) first[k][k] = 1;
cout << dfs(1, n);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n;
for (int i = 1; i < n; i++) {
cout << " " << i;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[12];
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
int x[4] = {0, 1, 0, -1}, y[4] = {1, 0, -1, 0}, cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'W') {
for (int k = 0; k < 4; k++) {
int xx = x[k] + i, yy = y[k] + j;
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
if (s[xx][yy] == 'P') {
cnt++;
break;
}
}
}
}
}
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
long long a[N];
long long l[N];
long long r[N];
int32_t main() {
long long ans = 0, n, i;
for (i = 1, scanf("%I64d", &n); i <= n; scanf("%I64d", &a[i++]))
;
for (i = 1; i <= n; l[i] = r[i] = i, i++)
;
for (i = 2; i <= n; i++) {
long long num = i;
while (num > 1 && a[num - 1] <= a[i]) num = l[num - 1];
l[i] = num;
}
for (i = n - 1; i >= 1; i--) {
long long num = i;
while (num < n && a[num + 1] < a[i]) num = r[num + 1];
r[i] = num;
}
for (i = 1; i <= n; ans += (i - l[i] + 1) * (r[i] - i + 1) * a[i], i++)
;
for (i = 1; i <= n; l[i] = r[i] = i, i++)
;
for (i = 2; i <= n; i++) {
long long num = i;
while (num > 1 && a[num - 1] >= a[i]) num = l[num - 1];
l[i] = num;
}
for (i = n - 1; i >= 1; i--) {
long long num = i;
while (num < n && a[num + 1] > a[i]) num = r[num + 1];
r[i] = num;
}
for (i = 1; i <= n; i++) {
ans -= (i - l[i] + 1) * (r[i] - i + 1) * a[i];
}
printf("%I64d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
const int MAXN = 205;
int priority[MAXN];
char str[MAXN];
int permutation[MAXN];
long long ways[MAXN][MAXN];
const long long INF = 1000000000000000001LL;
bool prioritary(int i, int j) { return priority[i] < priority[j]; }
void add(long long &where, const long long what) {
where += what;
if (where > INF) where = INF;
}
long long count(int len) {
memset(ways, 0, sizeof ways);
ways[0][0] = 1;
for (int i = 0; i < len; ++i) {
const char next = str[i];
for (int open = 0; open <= len; ++open) {
if (ways[i][open] == 0) continue;
if (next != ')') add(ways[i + 1][open + 1], ways[i][open]);
if (next != '(' and open > 0) add(ways[i + 1][open - 1], ways[i][open]);
}
}
return ways[len][0];
}
int main() {
int n, m;
long long k;
cin >> n >> m >> k;
assert(k < INF);
assert((n + m) % 2 == 1);
for (int i = 0; i < n + m - 1; ++i) {
priority[i] = n * m + 1;
permutation[i] = i;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int x;
cin >> x;
priority[i + j] = min(priority[i + j], x);
}
}
sort(permutation, permutation + n + m - 1, prioritary);
for (int i = 0; i < n + m - 1; ++i) str[i] = '*';
str[n + m - 1] = '\0';
for (int i = 0; i < n + m - 1; ++i) {
int pos = permutation[i];
str[pos] = '(';
long long add = count(n + m - 1);
if (k > add) {
str[pos] = ')';
k -= add;
}
}
assert(k == 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
printf("%c", str[i + j]);
}
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mod;
int DP[1005][105][2];
int powers[1005], powers2[1005], k, n;
int solve(int ind, int rem, bool change) {
if (rem == 0 && change)
return (ind != n ? ((powers[n - ind - 1] * 1LL * 9) % mod) : 1);
if (ind == n || (rem == 0 && change)) return 0;
int &temp = DP[ind][rem][change];
if (temp != -1) return temp;
temp = 0;
for (int i = 0; i < 10; i++)
temp += solve(ind + 1, (rem + (i * 1LL * powers2[ind]) % k) % k,
change || i != 0),
temp %= mod;
return temp;
}
int main() {
cin >> n >> k >> mod;
memset(DP, -1, sizeof(DP));
long long y = 1;
for (int i = 0; i <= n; i++) {
powers[i] = y;
y *= 10;
y %= mod;
}
y = 1;
for (int i = 0; i <= n; i++) {
powers2[i] = y;
y *= 10;
y %= k;
}
cout << solve(0, 0, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double ppow(double a, int b) {
if (b == 1) return a;
if (b == 0) return 1;
double y = ppow(a, b / 2);
y = y * y;
if (b % 2 == 1) y = y * a;
return y;
}
int main() {
int n, m, i;
double s = 1, ans = 0, c = 0, x;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) s = s / n;
for (i = 1; i <= n; i++) {
x = (double)i / n;
x = ppow(x, m);
ans += (x - c) * i;
c = x;
}
printf("%.8lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int _min(int x, int y) { return x < y ? x : y; }
int _max(int x, int y) { return x > y ? x : y; }
int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * f;
}
int a[510][510];
long long f[510][510], g[510][510];
int main() {
int n = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = read();
for (int i = 1; i <= n; i++) f[i][i] = 1;
for (int len = 2; len <= n; len++) {
for (int l = 1; l <= n - len + 1; l++) {
int r = l + len - 1;
if (a[l][r]) {
for (int k = l; k < r; k++)
(f[l][r] +=
(f[l][k] + g[l][k]) * (g[k + 1][r] + f[k + 1][r]) % mod) %= mod;
}
for (int k = l + 1; k < r; k++)
if (a[l][k]) {
(g[l][r] += f[l][k] * (f[k][r] + g[k][r])) %= mod;
}
}
}
long long ans = f[1][n];
(ans += g[1][n]) %= mod;
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
vector<int> gr[N];
long long int edges, z, o;
int col[N], vis[N];
void color(int n) {
for (int i = 0; i < gr[n].size(); i++) {
if (col[gr[n][i]] == -1) {
if (col[n] == 0) {
o++;
col[gr[n][i]] = 1;
} else {
z++;
col[gr[n][i]] = 0;
}
edges++;
color(gr[n][i]);
}
}
}
int main() {
int n, a, b;
cin >> n;
for (int i = 0; i < n - 1; i++) {
col[i] = -1;
cin >> a >> b;
gr[a].push_back(b);
gr[b].push_back(a);
}
col[n - 1] = -1;
col[n] = -1;
col[1] = 0;
z++;
color(1);
if (n == 1) {
cout << 0 << endl;
} else {
cout << z * o - edges << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
if (n % 2 == 1) {
cout << a[(n + 1) / 2] << endl;
} else {
cout << a[n / 2] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int lsb(int x) { return x & -x; }
set<pair<int, int> > s;
set<pair<pair<int, int>, pair<int, int> > > x;
int n;
long long h = 0;
int t[51];
pair<int, int> temp;
void rec(pair<int, int> p, int i, int z) {
pair<pair<int, int>, pair<int, int> > p1;
p1.first = p;
p1.second = make_pair(i, z);
if (((x).find(p1) != (x).end())) return;
x.insert(p1);
if (i > n)
return;
else {
int x, y, z1, z2;
if (z == 1)
x = 0, y = 1, z1 = 8, z2 = 2;
else if (z == 2)
x = 1, y = 1, z1 = 1, z2 = 3;
else if (z == 3)
x = 1, y = 0, z1 = 2, z2 = 4;
else if (z == 4)
x = 1, y = -1, z1 = 3, z2 = 5;
else if (z == 5)
x = 0, y = -1, z1 = 4, z2 = 6;
else if (z == 6)
x = -1, y = -1, z1 = 5, z2 = 7;
else if (z == 7)
x = -1, y = 0, z1 = 6, z2 = 8;
else if (z == 8)
x = -1, y = 1, z1 = 7, z2 = 1;
for (int j = 1; j <= t[i]; j++) {
p.first += x;
p.second += y;
s.insert(p);
h += 1;
}
rec(p, i + 1, z1);
rec(p, i + 1, z2);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
pair<int, int> p = make_pair(0, -1);
rec(p, 1, 1);
int c = s.size();
cout << c << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[4][7];
cin >> n;
bool b[10], c[10][4];
vector<int> v[10];
memset(b, false, sizeof b);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 6; ++j) {
cin >> a[i][j];
b[a[i][j]] = true;
c[a[i][j]][i] = true;
v[a[i][j]].push_back(i);
}
}
for (int i = 1; i < 10; ++i) {
if (!b[i]) {
cout << i - 1 << endl;
return 0;
}
}
bool bi;
for (int i = 1; i < 10; ++i) {
for (int j = 0; j < 10; ++j) {
bi = false;
for (auto it = v[i].begin(); it != v[i].end(); ++it) {
for (auto it2 = v[j].begin(); it2 != v[j].end(); ++it2) {
if ((*(it)) != (*(it2))) {
bi = true;
break;
}
}
if (bi) break;
}
if (!bi) {
int jwb = 10 * i + j;
cout << jwb - 1 << endl;
return 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int cnt1 = 0;
int cnt2 = 0;
bool f = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] < 97) {
cnt1++;
}
}
if (cnt1 == s.length()) {
for (int i = 0; i < s.length(); i++) {
s[i] += 32;
}
cout << s << endl;
f = 1;
return 0;
}
if (s[0] >= 97) {
for (int i = 1; i < s.length(); i++) {
if (s[i] < 97) {
cnt2++;
}
}
}
if (cnt2 == s.length() - 1) {
s[0] = s[0] - 32;
for (int i = 1; i < s.length(); i++) {
s[i] = s[i] + 32;
}
cout << s << endl;
f = 1;
return 0;
}
if (f == 0) {
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int N;
long long T[200002];
int segL[200002], segR[200002], G;
int f[200002], g[200002], from[200002][2];
int S_not_given[200002];
long long min_select(long long L1, long long R1, long long L2, long long R2,
long long need) {
L1 = N - L1 + 1;
L2 = N - L2 + 1;
R1 = N - R1 + 1;
R2 = N - R2 + 1;
std::swap(L1, R1);
std::swap(L2, R2);
long long ans = -1000000000;
for (long long number = 0; number <= R1 - L1 + 1; number++) {
long long low = need - (long long)(R1 + R1 - number + 1) * number / 2;
long long upp = need - (long long)(L1 + L1 + number - 1) * number / 2;
if (std::max(low, L2) <= std::min(upp, R2))
ans = std::max(ans, std::min(upp, R2));
}
return ans < 0 ? -1 : N - ans + 1;
}
int O[200002];
void construct(long long L, long long R, long long need) {
if (need == 0) return;
for (long long number = 0; number <= R - L + 1; number++) {
long long low = ((N - R + 1) + (N - R + 1) + number - 1) * number / 2;
long long upp = ((N - L + 1) + (N - L + 1) - number + 1) * number / 2;
if (low <= need && need <= upp) {
long long lnum = number - 1;
long long S;
while ((S = ((N - L + 1) + (N - L + 1) - lnum + 1) * lnum / 2 +
((N - R + 1) + (N - R + 1) + number - lnum - 1) *
(number - lnum) / 2) > need)
lnum--;
for (int i = L; i <= L + lnum - 1; i++) {
O[i] = 1;
need -= N - i + 1;
}
for (int i = R - (number - lnum) + 2; i <= R; i++) {
O[i] = 1;
need -= N - i + 1;
}
O[N - need + 1] = 1;
return;
}
}
}
void get_O(int i, int ty) {
if (!i) return;
O[(ty ? segR : f)[i]] = 1;
construct((from[i][ty] ? segR : f)[i - 1] + 1, segL[i] - 1,
T[(ty ? segR : segL)[i]] - T[(from[i][ty] ? segR : segL)[i - 1]] +
ty - from[i][ty] - (N - (ty ? segR : f)[i] + 1));
get_O(i - 1, from[i][ty]);
}
int try_final_ans(int ty) {
int L1 = (ty ? segR : f)[G - 1] + 1, R1 = segL[G] - 1;
if (T[segL[G]] == T[segR[G]]) {
long long need = T[segL[G]] - T[(ty ? segR : segL)[G - 1]] - ty;
if (need == 0) {
get_O(G - 1, ty);
for (int i = 1; i <= N; i++) putchar(O[i] + '0');
puts("");
return 1;
}
for (int number = 0; number <= R1 - L1 + 1; number++) {
long long low =
(long long)((N - R1 + 1) + (N - R1 + 1) + number - 1) * number / 2;
long long upp =
(long long)((N - L1 + 1) + (N - L1 + 1) - number + 1) * number / 2;
low = N + 1 - (need - low);
upp = N + 1 - (need - upp);
low = std::max(low, (long long)segL[G]);
upp = std::min(upp, (long long)N);
if (low <= upp && S_not_given[upp] - S_not_given[low - 1] > 0) {
int pos = low;
while (T[pos] != 0) pos++;
O[pos] = 1;
construct(L1, R1, need - (N - pos + 1));
get_O(G - 1, ty);
for (int i = 1; i <= N; i++) putchar(O[i] + '0');
puts("");
return 1;
}
}
}
if (segL[G] == segR[G] || T[segL[G]] - T[segR[G]] == 1) {
long long need = T[segR[G]] - T[(ty ? segR : segL)[G - 1]] + 1 - ty;
for (int number = 0; number <= R1 - L1 + 1; number++) {
long long low =
(long long)((N - R1 + 1) + (N - R1 + 1) + number - 1) * number / 2;
long long upp =
(long long)((N - L1 + 1) + (N - L1 + 1) - number + 1) * number / 2;
low = N + 1 - (need - low);
upp = N + 1 - (need - upp);
if (low <= segR[G] && segR[G] <= upp) {
O[segR[G]] = 1;
construct(L1, R1, need - (N - segR[G] + 1));
get_O(G - 1, ty);
for (int i = 1; i <= N; i++) putchar(O[i] + '0');
puts("");
return 1;
}
}
}
return 0;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%lld", T + i);
for (int i = 1; i <= N; i++)
S_not_given[i] = S_not_given[i - 1] + (T[i] == 0);
for (int i = 1; i <= N; i++)
if (T[i]) {
if (!G || T[segR[G]] < T[i]) {
segL[++G] = i;
segR[G] = i;
} else
segR[G] = i;
}
if (G == 0) {
for (int i = 1; i <= N; i++) putchar('0');
return 0;
}
f[0] = -1;
g[0] = 1;
segR[0] = 0;
T[0] = 0;
for (int i = 1; i <= G - 1; i++) {
int f_from_f = -1, f_from_g = -1, g_from_f = 0, g_from_g = 0;
if (T[segL[i]] == T[segR[i]]) {
if (f[i - 1] != -1)
f_from_f = min_select(f[i - 1] + 1, segL[i] - 1, segR[i] + 1,
segL[i + 1] - 1, T[segL[i]] - T[segL[i - 1]]);
if (g[i - 1])
f_from_g = min_select(segR[i - 1] + 1, segL[i] - 1, segR[i] + 1,
segL[i + 1] - 1, T[segL[i]] - T[segR[i - 1]] - 1);
}
if (segL[i] == segR[i] || T[segL[i]] - T[segR[i]] == 1) {
if (f[i - 1] != -1)
g_from_f = min_select(f[i - 1] + 1, segL[i] - 1, segR[i], segR[i],
T[segR[i]] - T[segL[i - 1]] + 1) != -1;
if (g[i - 1])
g_from_g = min_select(segR[i - 1] + 1, segL[i] - 1, segR[i], segR[i],
T[segR[i]] - T[segR[i - 1]]) != -1;
}
if (f_from_f == -1 && f_from_g == -1)
f[i] = -1;
else if (f_from_g == -1 || f_from_f != -1 && f_from_f <= f_from_g) {
f[i] = f_from_f;
from[i][0] = 0;
} else if (f_from_f == -1) {
f[i] = f_from_g;
from[i][0] = 1;
}
g[i] = g_from_f | g_from_g;
from[i][1] = !g_from_f;
}
if (f[G - 1] != -1)
if (try_final_ans(0)) return 0;
if (g[G - 1] != -1)
if (try_final_ans(1)) return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807LL;
struct Point {
long long x, y;
Point() {}
Point(const long long &_x, const long long &_y) : x(_x), y(_y) {}
Point operator-(const Point &a) const { return Point(x - a.x, y - a.y); }
int Quantarium() const {
if (y >= 0LL && x > 0LL) return 1;
if (y > 0LL && x <= 0LL) return 2;
if (y <= 0LL && x < 0LL) return 3;
if (y < 0LL && x >= 0LL) return 4;
assert(!(x == 0LL && y == 0LL));
assert(0);
return -1;
}
bool operator<(const Point &b) const {
const int qa = Quantarium(), qb = b.Quantarium();
if (qa != qb) return qa < qb;
switch (qa) {
case 1:
return y * b.x < b.y * x;
case 2:
return y * (-b.x) > b.y * (-x);
case 3:
return (-y) * (-b.x) < (-b.y) * (-x);
case 4:
return (-y) * b.x > (-b.y) * x;
default:
assert(0);
return true;
}
}
} P[100001];
struct Edge {
const int a, b;
int flow;
Edge() : a(), b() {}
Edge(const int _a, const int _b, const int _flow)
: a(_a), b(_b), flow(_flow) {}
bool operator<(const Edge &e) const {
assert(a == e.a);
return P[b] - P[a] < P[e.b] - P[a];
}
};
vector<Edge> EDGE;
vector<int> ET[100001], SUM[100000];
map<int, int> IDX[100000];
int Dfs(const int u, bool *vis) {
if (vis[u]) return 0;
vis[u] = true;
int ans = 1;
for (const int ei : ET[u]) {
const Edge &e = EDGE[ei];
const int flow = Dfs(e.b, vis);
ans += flow;
EDGE[ei].flow += flow, EDGE[ei ^ 1].flow -= flow;
}
return ans;
}
int N, M;
void CreateFlow() {
static bool vis[100001];
for (int i = 0; i <= N; i++) vis[i] = false;
assert(Dfs(N, vis) == N + 1);
}
void AddEdge(const int a, const int b) {
const int sz = EDGE.size();
EDGE.push_back(Edge(a, b, 0));
ET[a].push_back(sz);
}
int GetSum(const int a, const int o, const int b, const bool type) {
const vector<int> &sum = SUM[o];
const auto ita = IDX[o].find(a), itb = IDX[o].find(b);
assert(ita != IDX[o].end() && itb != IDX[o].end());
const int ia = (type ? itb : ita)->second;
const int ib = (type ? ita : itb)->second;
assert(ia != ib);
if (ia < ib)
return sum[ib - 1] - sum[ia];
else
return sum[(int)sum.size() - 1] - (sum[ia] - (ib ? sum[ib - 1] : 0));
}
bool CmpEdgeIdx(const int a, const int b) {
if (a == b) return false;
return EDGE[a] < EDGE[b];
}
int main() {
while (scanf("%d%d", &N, &M) == 2) {
for (int i = 0; i <= N; i++) ET[i].clear();
EDGE.clear();
for (int i = 0, a, b; i < M; i++) {
scanf("%d%d", &a, &b), a--, b--;
AddEdge(a, b), AddEdge(b, a);
}
for (int i = 0; i < N; i++) scanf("%I64d%I64d", &P[i].x, &P[i].y);
if (true) {
long long mn = INF;
int left = -1;
for (int i = 0; i < N; i++)
if (P[i].x < mn) mn = P[i].x, left = i;
assert(left != -1);
AddEdge(left, N), AddEdge(N, left);
P[N].x = -1e9 - 1, P[N].y = P[left].y;
}
CreateFlow();
for (int i = 0; i < N; i++) {
sort(ET[i].begin(), ET[i].end(), CmpEdgeIdx);
IDX[i].clear();
for (int j = 0; j < (int)ET[i].size(); j++) IDX[i][EDGE[ET[i][j]].b] = j;
SUM[i].clear();
int sum = 0;
for (const int ei : ET[i]) SUM[i].push_back(sum += EDGE[ei].flow);
assert(IDX[i].size() == ET[i].size() && SUM[i].size() == ET[i].size());
}
int querycount;
scanf("%d", &querycount);
for (int k; querycount--;) {
scanf("%d", &k);
vector<int> a;
for (int i = 0, v; i < k; i++) scanf("%d", &v), a.push_back(--v);
assert(k == (int)a.size() && k >= 3);
int ans1 = 0, ans2 = 0;
for (int i = 0; i < k; i++) {
ans1 += GetSum(a[i], a[(i + 1) % k], a[(i + 2) % k], false);
ans2 += GetSum(a[i], a[(i + 1) % k], a[(i + 2) % k], true);
}
printf("%d\n", -min(ans1, ans2));
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 1e5, M_MAX = 1e5;
int n, m, x[N_MAX], y[N_MAX], visited[N_MAX];
vector<int> G[N_MAX];
vector<int> a;
void dfs(int q, int p) {
a.push_back(q);
y[q]++;
visited[q] = 1;
for (int v : G[q]) {
if (v == p || visited[v]) continue;
dfs(v, q);
}
if (p != -1) {
if (y[q] % 2 != x[q] % 2) {
a.push_back(p);
y[p]++;
a.push_back(q);
y[q]++;
}
a.push_back(p);
y[p]++;
} else {
if (y[q] % 2 != x[q] % 2) {
a.erase(a.begin());
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < int(m); i++) {
int u, v;
cin >> u >> v;
--u, --v;
G[u].push_back(v);
G[v].push_back(u);
}
int c = 0, j;
for (int i = 0; i < int(n); i++) {
cin >> x[i];
if (x[i]) c++, j = i;
}
if (c == 0) {
cout << 0 << endl;
} else {
dfs(j, -1);
for (int i = 0; i < int(n); i++)
if (!visited[i] && x[i]) {
cout << -1 << endl;
return 0;
}
cout << a.size() << endl;
for (int x : a) cout << x + 1 << " ";
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 10e9;
int main() {
int n, m, i, j, a, b;
while (scanf("%d %d %d %d %d %d", &n, &m, &i, &j, &a, &b) != EOF) {
if ((i == 1 && j == 1) || (i == 1 && j == m) || (i == n && j == 1) ||
(i == n && j == m)) {
puts("0");
continue;
}
if ((i - a < 1 && i + a > n) || (j - b < 1 && j + b > m)) {
printf("Poor Inna and pony!\n");
continue;
}
int ans = INF;
if ((i - 1) % a == 0 && (j - 1) % b == 0 &&
((i - 1) / a) % 2 == ((j - 1) / b) % 2)
ans = min(ans, max((i - 1) / a, (j - 1) / b));
if ((i - 1) % a == 0 && (m - j) % b == 0 &&
((i - 1) / a) % 2 == ((m - j) / b) % 2)
ans = min(ans, max((i - 1) / a, (m - j) / b));
if ((n - i) % a == 0 && (j - 1) % b == 0 &&
((n - i) / a) % 2 == ((j - 1) / b) % 2)
ans = min(ans, max((n - i) / a, (j - 1) / b));
if ((n - i) % a == 0 && (m - j) % b == 0 &&
((n - i) / a) % 2 == ((m - j) / b) % 2)
ans = min(ans, max((n - i) / a, (m - j) / b));
if (ans == INF)
puts("Poor Inna and pony!");
else
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MD = 1e9 + 7;
const double pi = acos(-1);
struct segmentTree {
long long tl = 1, tr = (1ll << 21);
segmentTree* left = nullptr;
segmentTree* right = nullptr;
long long val = 0;
segmentTree(long long tl, long long tr) : tl(tl), tr(tr) {}
segmentTree() = default;
void createSons() {
long long tm = (tl + tr) / 2;
if (!left) {
left = new segmentTree(tl, tm);
}
if (!right) {
right = new segmentTree(tm + 1, tr);
}
}
void update(long long pos, long long val) {
if (tl == tr) {
this->val = val;
return;
}
long long tm = (tl + tr) / 2;
createSons();
if (pos <= tm) {
left->update(pos, val);
} else {
right->update(pos, val);
}
this->val = (left->val) ^ (right->val);
}
long long get(long long l, long long r) {
if (l > r) {
return 0;
}
if (l == tl && tr == r) {
return val;
}
long long tm = (tl + tr) / 2;
createSons();
return (left->get(l, min(r, tm))) ^ (right->get(max(tm + 1, l), r));
}
};
ostream& operator<<(ostream& stream, const vector<long long>& v) {
for (auto i : v) {
stream << i << "\n";
}
return stream;
}
pair<long long, long long> operator+=(pair<long long, long long>& a,
const pair<long long, long long>& b) {
a.first += b.first;
a.second += b.second;
return a;
};
long long sqr(long long a) { return a * a % MD; }
long long binpow(long long a, long long b) {
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
return sqr(binpow(a, b / 2));
}
return a * binpow(a, b - 1) % MD;
}
long long fact(long long a) {
long long res = 1;
for (long long i = 2; i <= a; i++) {
res *= i;
res %= MD;
}
return res;
}
struct edge {
long long u, v, c;
bool operator<(const edge& other) const {
if (c == other.c) {
if (u == other.u) {
return v < other.v;
}
return u < other.u;
}
return c < other.c;
}
};
struct query {
long long u, v, k, ind;
bool operator<(const query& other) const {
if (k == other.k) {
if (u == other.u) {
if (ind == other.ind) {
return ind < other.ind;
}
return v < other.v;
}
return u < other.u;
}
return k < other.k;
}
};
vector<long long> g[100006];
long long timer = 1;
long long subTreeSize[100006];
long long pred[100006];
long long tIn[100006];
long long tOut[100006];
void dfs(long long v) {
tIn[v] = timer++;
subTreeSize[v] = 1;
for (auto i : g[v]) {
if (!tIn[i]) {
pred[i] = v;
dfs(i);
subTreeSize[v] += subTreeSize[i];
}
}
tOut[v] = timer++;
}
bool isPred(long long a, long long b) {
return (tIn[a] <= tIn[b] && tOut[b] <= tOut[a]);
}
long long chainNumOfVertex[100006], inChainPositionOfVertex[100006],
chainSize[100006], chainRoot[100006], chainsCount;
vector<segmentTree> segmTrees;
struct HLD {
void build(long long v, long long chainNum) {
chainNumOfVertex[v] = chainNum;
inChainPositionOfVertex[v] = chainSize[chainNum];
chainSize[chainNum]++;
if (chainSize[chainNum] == 1) {
chainRoot[chainNum] = v;
}
long long maxChild = -1;
for (auto i : g[v]) {
if (i != pred[v] &&
(maxChild == -1 || subTreeSize[i] > subTreeSize[maxChild])) {
maxChild = i;
}
}
if (maxChild != -1) {
for (auto i : g[v]) {
if (i == pred[v]) {
continue;
}
if (i == maxChild) {
build(i, chainNum);
} else {
segmTrees.push_back(segmentTree());
build(i, ++chainsCount);
}
}
}
}
long long get(long long a, long long b) {
long long res = 0;
for (long long i = 1; i <= 2; i++) {
while (1) {
if (isPred(chainRoot[chainNumOfVertex[a]], b)) {
break;
}
segmTrees[chainNumOfVertex[a]].tl = 0;
segmTrees[chainNumOfVertex[a]].tr = chainSize[chainNumOfVertex[a]];
res ^=
segmTrees[chainNumOfVertex[a]].get(0, inChainPositionOfVertex[a]);
a = pred[chainRoot[chainNumOfVertex[a]]];
}
swap(a, b);
}
if (inChainPositionOfVertex[a] > inChainPositionOfVertex[b]) {
swap(a, b);
}
segmTrees[chainNumOfVertex[a]].tl = 0;
segmTrees[chainNumOfVertex[a]].tr = chainSize[chainNumOfVertex[a]];
res ^= segmTrees[chainNumOfVertex[a]].get(inChainPositionOfVertex[a] + 1,
inChainPositionOfVertex[b]);
return res;
}
void update(long long a, long long val) {
segmTrees[chainNumOfVertex[a]].tl = 0;
segmTrees[chainNumOfVertex[a]].tr = chainSize[chainNumOfVertex[a]];
segmTrees[chainNumOfVertex[a]].update(inChainPositionOfVertex[a], val);
}
void add(edge e) {
if (pred[e.u] == e.v) {
update(e.u, e.c);
} else {
update(e.v, e.c);
}
}
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string st;
cin >> st;
st = '0' + st;
long long ans = 0;
for (long long i = 1; i < st.size(); i++) {
if (st[i] == '1') {
ans = max(2 * i, ans);
ans = max((n - i + 1) * 2, ans);
}
}
cout << max(ans, n) << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, k;
int a[MAXN];
void read_input() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
}
int mi[MAXN];
vector<int> graph[MAXN];
int in[MAXN], out[MAXN];
int timer;
void dfs(int v) {
in[v] = timer++;
for (auto x : graph[v]) {
dfs(x);
}
out[v] = timer++;
}
const int TSIZE = (1 << 23);
int tree[TSIZE], lazy[TSIZE];
void push(int k, int l, int r) {
if (lazy[k]) {
tree[k] += lazy[k];
if (l != r) {
lazy[k * 2] += lazy[k];
lazy[k * 2 + 1] += lazy[k];
}
lazy[k] = 0;
}
}
void update(int k, int l, int r, int i, int j, int val) {
push(k, l, r);
if (r < i || l > j || l > r) return;
if (r <= j && l >= i) {
tree[k] += val;
if (l != r) {
lazy[k * 2] += val;
lazy[k * 2 + 1] += val;
}
return;
}
int middle = (l + r) >> 1;
update(k * 2, l, middle, i, j, val);
update(k * 2 + 1, middle + 1, r, i, j, val);
tree[k] = max(tree[k * 2], tree[k * 2 + 1]);
}
void solve() {
stack<pair<int, int>> st;
for (int i = n; i >= 1; i--) {
pair<int, int> temp = {i, a[i]};
while (!st.empty() && st.top().second <= a[i]) {
st.pop();
}
int ans = n + 1;
if (!st.empty()) ans = st.top().first;
st.push(temp);
graph[ans].push_back(i);
}
dfs(n + 1);
for (int i = 1; i <= k - 1; i++) {
update(1, 0, timer - 1, in[i], out[i], 1);
}
for (int i = k; i <= n; i++) {
update(1, 0, timer - 1, in[i], out[i], 1);
push(1, 0, timer - 1);
cout << tree[1] << " ";
update(1, 0, timer - 1, in[i - k + 1], out[i - k + 1], -1);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
read_input();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int i;
int permu[100001];
int used[100001];
vector<int> Cycle[100001];
int found1 = 0, foundodd = 0, found2 = 0;
vector<int> get_cycle(int idx) {
int cyc = idx;
vector<int> res;
while (true) {
if (used[idx]) break;
res.push_back(idx);
used[idx] = cyc;
idx = permu[idx];
}
return res;
}
void trace(int idx, int V_N) {
if (used[idx]) return;
used[idx] = V_N;
trace(permu[idx], 3 - V_N);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &permu[i]);
for (i = 1; i <= n; i++) {
if (used[i]) continue;
Cycle[i] = get_cycle(i);
if (Cycle[i].size() == 1) {
found1 = i;
} else if (Cycle[i].size() % 2) {
foundodd = i;
} else if (Cycle[i].size() == 2) {
found2 = i;
}
}
if (found1) {
cout << "YES" << endl;
for (i = 1; i <= n; i++) {
if (i != found1) cout << found1 << " " << i << endl;
}
return 0;
}
if (foundodd) {
cout << "NO" << endl;
return 0;
}
if (found2 == 0) {
cout << "NO" << endl;
return 0;
}
int v1, v2;
v1 = Cycle[found2][0];
v2 = Cycle[found2][1];
cout << "YES" << endl;
cout << v1 << " " << v2 << endl;
for (i = 1; i <= n; i++) used[i] = 0;
for (i = 1; i <= n; i++) {
if (used[i]) continue;
trace(i, 1);
}
for (i = 1; i <= n; i++) {
if (i == v1 || i == v2) continue;
if (used[i] == 1)
cout << i << " " << v1 << endl;
else
cout << i << " " << v2 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1e18;
const int mod = 998244353;
const int maxn = 1e5 + 2;
const int mov[4][2] = {-1, 0, 1, 0, 0, 1, 0, -1};
const int Mov[8][2] = {-1, -1, -1, 0, -1, 1, 0, -1, 0, 1, 1, -1, 1, 0, 1, 1};
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void read(int &x) {
x = 0;
int f = 1;
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();
}
x *= f;
return;
}
int main(void) {
std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
while (cin >> n) {
std::vector<long long> a(n);
std::vector<long long> b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i) {
a[i] *= (long long)(i + 1) * (n - i);
}
sort(a.begin(), a.end());
long long ans = 0;
for (long long i = 0; i < n; ++i) {
ans += (a[i] % mod * b[n - 1 - i] % mod) % mod;
ans %= mod;
}
cout << (ans + mod) % mod << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
long long Max(long long a, long long b) { return a > b ? a : b; }
long long Min(long long a, long long b) { return a < b ? a : b; }
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = ((x % p) * (x % p)) % p;
}
return res;
}
int main() {
string x(2 * 100000 + 5, '0'), y(1, '0');
cin >> x;
long long m, p = 0;
cin >> m;
long long l = x.length();
long long beg, en;
map<long long, long long> z;
for (long long i = 0; i < m; i++) {
cin >> beg;
z[beg - 1]++;
}
for (long long i = 0; i < l / 2; i++) {
p = p + z[i];
if (p % 2 == 1) {
y[0] = x[i];
x[i] = x[l - i - 1];
x[l - i - 1] = y[0];
}
}
cout << x;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<char> v;
getline(cin, s);
for (int i = 0; i < (int)s.size(); ++i) {
if (s[i] >= 'a' && s[i] <= 'z')
v.push_back(s[i]);
else if (s[i] == ',' || s[i] == '!' || s[i] == '?' || s[i] == '.') {
while ((*v.rbegin() < 'a' || *v.rbegin() > 'z') && !v.empty())
v.pop_back();
v.push_back(s[i]);
v.push_back(' ');
} else {
if (!i)
continue;
else {
if (*v.rbegin() == '.' || *v.rbegin() == ',' || *v.rbegin() == '!' ||
*v.rbegin() == '?' || (*v.rbegin() >= 'a' && *v.rbegin() <= 'z'))
v.push_back(' ');
else
continue;
}
}
}
for (int i = 0; i < (int)v.size(); ++i) cout << v[i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const int maxn = 100005, maxnode = 16500005;
int mx, my, mz, n, m, k, lx, rx, ly, ry, lz, rz, cnt, lc[maxnode], rc[maxnode],
lv[maxnode], rv[maxnode], rt[maxn << 2];
inline bool Open(int x, int y, int z) {
return lx <= x && x <= rx && ly <= y && y <= ry && lz <= z && z <= rz;
}
inline void update(int &o, int l, int r, int y, int z) {
if (!o) o = ++cnt, rv[o] = mz + 1;
if (lz <= z) rv[o] = min(rv[o], z);
if (z <= rz) lv[o] = max(lv[o], z);
if (l == r) return;
int mid = (l + r) >> 1;
if (y <= mid)
update(lc[o], l, mid, y, z);
else
update(rc[o], mid + 1, r, y, z);
}
inline void modify(int o, int l, int r, int x, int y, int z) {
update(rt[o], 1, my, y, z);
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid)
modify(o << 1, l, mid, x, y, z);
else
modify(o << 1 | 1, mid + 1, r, x, y, z);
}
inline bool getans(int o, int l, int r, int yl, int yr, int zl, int zr) {
if (!o) return 1;
if (yl <= l && r <= yr) return lv[o] < zl && zr < rv[o];
bool res = 1;
int mid = (l + r) >> 1;
if (yl <= mid) res &= getans(lc[o], l, mid, yl, yr, zl, zr);
if (yr > mid) res &= getans(rc[o], mid + 1, r, yl, yr, zl, zr);
return res;
}
inline bool query(int o, int l, int r, int xl, int xr, int yl, int yr, int zl,
int zr) {
if (xl <= l && r <= xr) return getans(rt[o], 1, my, yl, yr, zl, zr);
bool res = 1;
int mid = (l + r) >> 1;
if (xl <= mid) res &= query(o << 1, l, mid, xl, xr, yl, yr, zl, zr);
if (xr > mid) res &= query(o << 1 | 1, mid + 1, r, xl, xr, yl, yr, zl, zr);
return res;
}
inline void solve(int x, int y, int z) {
if (Open(x, y, z)) return (void)puts("OPEN");
if (query(1, 1, mx, min(lx, x), max(rx, x), min(ly, y), max(ry, y),
min(lz, z), max(rz, z)))
return (void)puts("UNKNOWN");
return (void)puts("CLOSED");
}
int main() {
read(mx), read(my), read(mz), read(n), read(m), read(k);
lx = mx, ly = my, lz = mz;
for (int i = 1, x, y, z; i <= n; ++i) {
read(x), read(y), read(z);
lx = min(lx, x), rx = max(rx, x);
ly = min(ly, y), ry = max(ry, y);
lz = min(lz, z), rz = max(rz, z);
}
for (int i = 1, x, y, z; i <= m; ++i) {
read(x), read(y), read(z);
if (Open(x, y, z)) return 0 * puts("INCORRECT");
modify(1, 1, mx, x, y, z);
}
puts("CORRECT");
for (int i = 1, x, y, z; i <= k; ++i)
read(x), read(y), read(z), solve(x, y, z);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long res = 0;
while (n) {
if (n % k == 0) {
n /= k;
res++;
} else {
res += (n % k);
n -= (n % k);
}
}
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5;
int n, a[mxN];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int curr_value = INT_MIN, curr_cnt = 0, ans = 0;
bool flag = true;
sort(a, a + n);
for (int i = 0; i < n; i++) {
curr_value = max(curr_value, a[i]);
curr_cnt++;
if (curr_value == curr_cnt) {
ans++;
curr_value = INT_MIN, curr_cnt = 0;
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[30][3000][60], num[30], indexx[3000], cnt;
const long long mod = 2520LL;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long dfs(long long pos, long long presum, long long prelcm, bool flag) {
if (pos == 0) return presum % prelcm == 0;
if (flag && dp[pos][presum][indexx[prelcm]] != -1)
return dp[pos][presum][indexx[prelcm]];
long long u = flag ? 9 : num[pos];
long long ans = 0;
for (long long d = 0; d <= u; d++) {
long long newsum = (presum * 10 + d) % mod;
long long newlcm = prelcm;
if (d) newlcm = lcm(d, newlcm);
ans += dfs(pos - 1, newsum, newlcm, flag || d < u);
}
if (flag) dp[pos][presum][indexx[prelcm]] = ans;
return ans;
}
long long solve(long long x) {
long long len = 0;
while (x) {
num[++len] = x % 10;
x /= 10;
}
return dfs(len, 0, 1, 0);
}
int main() {
long long T, A, B;
cnt = 0;
for (long long i = 1; i <= mod; i++)
if (mod % i == 0) indexx[i] = cnt++;
memset(dp, -1, sizeof(dp));
cin >> T;
while (T--) {
cin >> A >> B;
cout << solve(B) - solve(A - 1) << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, L, R;
int a[1005];
int b[1005];
int mem[1005][2];
char s[1005][1005];
int f(int x, int color) {
int i, j;
if (x == m) return 0;
if (!mem[x][color]) {
mem[x][color] = 1 << 30;
for (i = x + L - 1, j = L - 1; i < m && j < R; i++, j++) {
if (color == 0)
mem[x][color] = min(mem[x][color], a[i] - a[x - 1] + f(i + 1, !color));
else
mem[x][color] = min(mem[x][color], b[i] - b[x - 1] + f(i + 1, !color));
}
}
return mem[x][color];
}
int main() {
int i, j;
scanf("%d%d%d%d", &n, &m, &L, &R);
for (i = 0; i < n; i++) scanf(" %s", s[i]);
for (i = 0; i < m; i++) {
a[i] = a[i - 1];
b[i] = b[i - 1];
for (j = 0; j < n; j++) {
if (s[j][i] == '#')
a[i]++;
else
b[i]++;
}
}
printf("%d", min(f(0, 0), f(0, 1)));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
int n, m, res1, res2;
int x[1111], y[1111];
int main() {
cin >> n >> m;
res1 = n, res2 = n;
for (int i = 0; i < m; i++) {
int q, w;
cin >> q >> w;
q--;
w--;
x[q] = -1;
y[w] = -1;
}
x[0] = -1;
x[n - 1] = -1;
y[0] = -1;
y[n - 1] = -1;
if (n % 2 == 1 && x[n / 2] != -1 && y[n / 2] != -1) res1--;
for (int i = 0; i < n; i++) res1 += x[i];
for (int i = 0; i < n; i++) res2 += y[i];
cout << res1 + res2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (1e9) + 7;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int>> arr(n, vector<int>(m, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 || i == n - 1) {
if (j == 0 || j == m - 1) {
arr[i][j] = max(arr[i][j], 2);
} else {
arr[i][j] = max(arr[i][j], 3);
}
continue;
}
if (j == 0 || j == m - 1) {
if (i == 0 || i == n - 1) {
arr[i][j] = max(arr[i][j], 2);
} else {
arr[i][j] = max(arr[i][j], 3);
}
continue;
} else {
arr[i][j] = max(arr[i][j], 4);
}
}
}
auto check = [&](int i, int j) {
return (i >= 0) && (j >= 0) && (i < n) && (j < m);
};
bool pos = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int ng = 0;
if (check(i - 1, j)) ng++;
if (check(i + 1, j)) ng++;
if (check(i, j - 1)) ng++;
if (check(i, j + 1)) ng++;
if (arr[i][j] > ng) {
pos = 0;
}
}
}
if (pos) {
cout << "YES" << endl;
for (auto i : arr) {
for (auto j : i) {
cout << j << " ";
}
cout << endl;
}
} else {
cout << "NO" << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 260;
int a[MAXN][MAXN];
int b[MAXN][MAXN];
int n, m;
void impossible() {
cout << -1 << endl;
exit(0);
}
void fillWeak(queue<pair<int, int> > &q, int rx, int lx) {
for (int x = rx - 1; x > lx; x--) {
assert(!q.empty());
pair<int, int> p = q.front();
q.pop();
b[p.first][p.second] = x;
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
vector<pair<int, int> > vp;
for (int i = 1; i <= n; i++) {
int mxid = 1;
for (int j = 2; j <= m; j++) {
if (a[i][j] > a[i][mxid]) mxid = j;
}
vp.emplace_back(a[i][mxid], i);
}
for (int j = 1; j <= m; j++) {
int mxid = 1;
for (int i = 2; i <= n; i++) {
if (a[i][j] > a[mxid][j]) mxid = i;
}
vp.emplace_back(a[mxid][j], -j);
}
sort(vp.rbegin(), vp.rend());
queue<pair<int, int> > q;
int R = 0;
int C = 0;
int _R = 0;
int _C = 0;
for (int i = 0; i < vp.size(); i++) {
if (i > 0) fillWeak(q, vp[i - 1].first, vp[i].first);
if (i + 1 < vp.size() && vp[i].first == vp[i + 1].first) {
R++;
C++;
_R = R;
_C = C;
b[R][C] = vp[i].first;
for (int y = C - 1; y > 0; y--) q.emplace(R, y);
for (int x = R - 1; x > 0; x--) q.emplace(x, C);
i++;
} else {
if (vp[i].second > 0) {
R++;
for (int y = _C - 1; y > 0; y--) q.emplace(R, y);
for (int y = _C + 1; y <= C; y++) q.emplace(R, y);
b[R][_C] = vp[i].first;
} else {
C++;
for (int x = _R - 1; x > 0; x--) q.emplace(x, C);
for (int x = _R + 1; x <= R; x++) q.emplace(x, C);
b[_R][C] = vp[i].first;
}
}
}
fillWeak(q, vp.back().first, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << b[i][j] << " ";
}
cout << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> graph[300010];
int a[300010];
int bad[300010];
set<pair<int, int> > s;
char ans[300010];
void func(int x) {
s.erase(make_pair(-bad[x], x));
bad[x] = 0;
int i;
for ((i) = 0; (i) < (int)(graph[x].size()); (i)++)
if (a[x] == a[graph[x][i]]) bad[x]++;
s.insert(make_pair(-bad[x], x));
}
int main(void) {
int M, x, y, i;
cin >> N >> M;
for ((i) = 0; (i) < (int)(M); (i)++) {
scanf("%d%d", &x, &y);
x--;
y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
for ((i) = 0; (i) < (int)(N); (i)++) bad[i] = graph[i].size();
for ((i) = 0; (i) < (int)(N); (i)++) s.insert(make_pair(-bad[i], i));
while (1) {
int x = (s.begin()->second);
if (bad[x] <= 1) break;
a[x] = (a[x] ^ 1);
func(x);
for ((i) = 0; (i) < (int)(graph[x].size()); (i)++) func(graph[x][i]);
}
for ((i) = 0; (i) < (int)(N); (i)++) ans[i] = ((a[i] == 0) ? '0' : '1');
ans[N] = '\0';
printf("%s\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int> > g, G;
short dp[5000][2501][3][2];
int in[5000];
int last[5000], u[5000], v[5000], nxt[5000], e;
void addEdge(int a, int b) {
u[e] = a;
v[e] = b;
nxt[e] = last[a];
last[a] = e;
++e;
}
int DFS(int u, int p) {
int ret = 0, me = 1;
for (int i = 0; i < g[u].size(); ++i)
if (g[u][i] != p) {
addEdge(u, g[u][i]);
ret += DFS(g[u][i], u);
me = 0;
}
return in[u] = ret + me;
}
short calc(int e, int rem, char l, bool me) {
if (e == -1) {
if (me) return rem ? 10000 : 0;
if (rem) return l != 2 && l != 1;
return l != 2 && l != 0;
}
short &ret = dp[e][rem][l][me];
if (ret != -1) return ret;
ret = 10000;
if (!me)
ret = min((l != 2 && l != 0) + calc(e, rem, 0, true),
(l != 2 && l != 1) + calc(e, rem, 1, true));
else {
for (int take = 0; take <= rem && take <= in[v[e]]; ++take)
ret = min((int)ret, calc(last[v[e]], take, l, false) +
calc(nxt[e], rem - take, l, me));
}
return ret;
}
int main() {
scanf("%d", &n);
g.resize(n);
if (n == 2) {
puts("1");
return 0;
}
for (int i = 1, a, b; i < n; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
int leaf = 0, root;
for (int i = 0; i < n; ++i)
if (g[i].size() == 1)
++leaf;
else
root = i;
assert(leaf % 2 == 0);
memset(last, -1, sizeof(last));
DFS(root, -1);
memset(dp, -1, sizeof(dp));
printf("%d\n", (int)calc(last[root], leaf / 2, 2, false));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
const long long Base = 127;
const long long Mod1 = 1000000007;
const long long Mod2 = 1000000009;
long long power_base1[MaxN], power_base2[MaxN];
struct Hash {
int len;
vector<long long> Val1, Val2;
void init(string &s) {
len = s.length();
s = '0' + s;
Val1.assign(len + 1, 0);
Val2.assign(len + 1, 0);
for (int i = 1; i <= len; i++) {
Val1[i] = (Val1[i - 1] * Base + (s[i] - 'a')) % Mod1;
Val2[i] = (Val2[i - 1] * Base + (s[i] - 'a')) % Mod2;
}
}
pair<long long, long long> Get(int Left, int Right) {
return make_pair(
(Val1[Right] - Val1[Left - 1] * power_base1[Right - Left + 1] +
Mod1 * Mod1) %
Mod1,
(Val2[Right] - Val2[Left - 1] * power_base2[Right - Left + 1] +
Mod2 * Mod2) %
Mod2);
}
};
void prep() {
power_base1[0] = 1;
power_base2[0] = 1;
for (int i = 1; i < MaxN; i++) {
power_base1[i] = power_base1[i - 1] * Base % Mod1;
power_base2[i] = power_base2[i - 1] * Base % Mod2;
}
}
int n;
string a, b;
Hash aHash, bHash;
int cnta[MaxN][26], cntb[MaxN][26];
map<tuple<int, int, int, int>, bool> mp;
int getMap(const map<tuple<int, int, int, int>, bool> &mp,
tuple<int, int, int, int> val) {
auto it = mp.find(val);
return (it == mp.end() ? -1 : it->second);
}
bool Check(int x, int y, int u, int v) {
int tg = getMap(mp, make_tuple(x, y, u, v));
if (tg != -1) {
return tg;
}
bool &res = mp[make_tuple(x, y, u, v)] = true;
if (aHash.Get(x, y) == bHash.Get(u, v)) {
return res = true;
}
for (int i = 0; i < 26; i++) {
if (cnta[y][i] - cnta[x - 1][i] != cntb[v][i] - cntb[u - 1][i]) {
return res = false;
}
}
if ((y - x + 1) % 2 != 0) {
return res = false;
}
int Mida = (x + y) / 2, Midb = (u + v) / 2;
return res = ((Check(x, Mida, u, Midb) && Check(Mida + 1, y, Midb + 1, v)) ||
(Check(Mida + 1, y, u, Midb) && Check(x, Mida, Midb + 1, v)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
prep();
cin >> a >> b;
n = a.size();
aHash.init(a);
bHash.init(b);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
cnta[i][j] = cnta[i - 1][j];
cntb[i][j] = cntb[i - 1][j];
}
cnta[i][a[i] - 'a']++;
cntb[i][b[i] - 'a']++;
}
cout << (Check(1, n, 1, n) ? "YES\n" : "NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int n, m, tot, col[N];
set<int> S;
vector<int> c[N], e[N];
void dfs(int u, int p) {
vector<int> tmp;
for (int i = (0); i < (((int)(c[u]).size())); ++i) {
int ice = c[u][i];
if (~col[ice]) {
tmp.push_back(col[ice]);
S.erase(tmp.back());
}
}
for (int i = (0); i < (((int)(c[u]).size())); ++i) {
int ice = c[u][i];
if (col[ice] == -1) {
col[ice] = *S.begin();
tmp.push_back(col[ice]);
S.erase(tmp.back());
}
}
for (int i = (0); i < (((int)(tmp).size())); ++i) S.insert(tmp[i]);
for (int i = (0); i < (((int)(e[u]).size())); ++i) {
int v = e[u][i];
if (v == p) continue;
dfs(v, u);
}
}
int main() {
scanf("%d%d", &n, &m);
tot = 1;
for (int i = (1); i < (n + 1); ++i) {
int si;
scanf("%d", &si);
tot = max(tot, si);
for (int j = (0); j < (si); ++j) {
int x;
scanf("%d", &x);
c[i].push_back(x);
}
}
for (int i = (1); i < (tot + 1); ++i) S.insert(i);
for (int i = (1); i < (n); ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
memset(col, -1, sizeof(col));
dfs(1, -1);
printf("%d\n", tot);
for (int i = (1); i < (m + 1); ++i)
printf("%d%c", ~col[i] ? col[i] : 1, " \n"[i == m]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
string ans = "";
if (n == 1)
cout << -1 << endl;
else {
if (n == 2)
cout << 23 << endl;
else {
ans = "23";
for (int g = 2; g < n; g++) ans = ans + '9';
cout << ans << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, flag = 0, dist;
;
char tmp;
cin >> n >> m;
set<int> s;
for (int i = 0; i < n; i++) {
dist = 0;
for (int j = 0; j < m; j++) {
cin >> tmp;
if (dist == 0 && tmp == 'S') {
cout << -1;
exit(0);
}
if (tmp == 'G') {
dist++;
continue;
}
if (dist && tmp == '*') dist++;
if (tmp == 'S') {
s.insert(dist);
int k = m - j - 1;
while (k--) cin >> tmp;
break;
}
}
}
int moves = 0;
cout << s.size();
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
struct T {
long long a, b, c;
int m;
T(long long a = 0, long long b = 0, long long c = 0, int m = 0)
: a(a), b(b), c(c), m(m) {}
};
bool operator<(const T &a, const T &b) {
if (a.b != b.b) return a.b < b.b;
if (a.c != b.c) return a.c < b.c;
return a.a > b.a;
}
T m[600100];
int k;
int b, n, v[30][3];
long long x;
int m1, m2;
void rec(int i, T t) {
if (i == b) {
m[k] = t;
k++;
} else {
rec(i + 1, T(t.a + v[i][0], t.b + v[i][1], t.c, t.m * 3 + 2));
rec(i + 1, T(t.a + v[i][0], t.b, t.c + v[i][2], t.m * 3 + 1));
rec(i + 1, T(t.a, t.b + v[i][1], t.c + v[i][2], t.m * 3 + 0));
}
}
int fnd(const T &t) {
int l, r, c;
for (l = 0, r = k - 1; l <= r;) {
c = (l + r) / 2;
if (m[c].b < t.b)
l = c + 1;
else if (m[c].b > t.b)
r = c - 1;
else if (m[c].c < t.c)
l = c + 1;
else if (m[c].c > t.c)
r = c - 1;
else
return c;
}
return -1;
}
void rec2(int i, T t) {
if (i == n) {
t.b = t.a - t.b;
t.c = t.a - t.c;
int f = fnd(t);
if (f != -1 && t.a + m[f].a > x) {
x = t.a + m[f].a;
m1 = m[f].m;
m2 = t.m;
}
} else {
rec2(i + 1, T(t.a + v[i][0], t.b + v[i][1], t.c, t.m * 3 + 2));
rec2(i + 1, T(t.a + v[i][0], t.b, t.c + v[i][2], t.m * 3 + 1));
rec2(i + 1, T(t.a, t.b + v[i][1], t.c + v[i][2], t.m * 3 + 0));
}
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++)
for (j = 0; j < 3; scanf("%d", &v[i][j]), j++)
;
b = 12;
if (b > n) b = n;
rec(0, T(0, 0, 0, 0));
for (i = 0; i < k; m[i].b -= m[i].a, m[i].c -= m[i].a, i++)
;
sort(m, m + k);
j = 0;
for (i = 0; i < k; i++)
if (!j || m[i].b != m[j - 1].b || m[i].c != m[j - 1].c) {
m[j] = m[i];
j++;
}
k = j;
x = -1000000000000000ll;
rec2(b, T(0, 0, 0, 0));
if (x == -1000000000000000ll)
printf("Impossible\n");
else {
int a[30];
for (i = n - 1; i >= b; a[i] = m2 % 3, m2 /= 3, i--)
;
for (i = b - 1; i >= 0; a[i] = m1 % 3, m1 /= 3, i--)
;
for (i = 0; i < n; i++)
if (a[i] == 0)
printf("MW\n");
else if (a[i] == 1)
printf("LW\n");
else
printf("LM\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i];
if (i != v.size() - 1) cout << endl;
};
return os;
}
template <typename T>
void Out(T x) {
cout << x << endl;
}
template <typename T1, typename T2>
void Ans(bool first, T1 y, T2 n) {
if (first)
Out(y);
else
Out(n);
}
using vec = vector<long long>;
using mat = vector<vec>;
using Pii = pair<long long, long long>;
using PiP = pair<long long, Pii>;
using PPi = pair<Pii, long long>;
using bools = vector<bool>;
using pairs = vector<Pii>;
const long long mod = 1000000007;
template <long long MOD>
struct ModInt {
using ll = long long;
ll val;
void setval(ll v) { val = v % MOD; };
ModInt() : val(0) {}
ModInt(ll v) { setval(v); };
ModInt operator+(const ModInt &x) const { return ModInt(val + x.val); }
ModInt operator-(const ModInt &x) const { return ModInt(val - x.val + MOD); }
ModInt operator*(const ModInt &x) const { return ModInt(val * x.val); }
ModInt operator/(const ModInt &x) const { return *this * x.inv(); }
ModInt operator-() const { return ModInt(MOD - val); }
ModInt operator+=(const ModInt &x) { return *this = *this + x; }
ModInt operator-=(const ModInt &x) { return *this = *this - x; }
ModInt operator*=(const ModInt &x) { return *this = *this * x; }
ModInt operator/=(const ModInt &x) { return *this = *this / x; }
friend ostream &operator<<(ostream &os, const ModInt &x) {
os << x.val;
return os;
}
friend istream &operator>>(istream &is, ModInt &x) {
is >> x.val;
x.val = (x.val % MOD + MOD) % MOD;
return is;
}
ModInt pow(ll n) const {
ModInt a = 1;
if (n == 0) return a;
long long i0 = 64 - __builtin_clzll(n);
for (long long i = i0 - 1; i >= 0; i--) {
a = a * a;
if ((n >> i) & 1) a *= (*this);
}
return a;
}
ModInt inv() const { return this->pow(MOD - 2); }
};
using mint = ModInt<mod>;
mint pow(mint x, long long n) { return x.pow(n); }
using mvec = vector<mint>;
using mmat = vector<mvec>;
struct Combination {
vector<mint> fact, invfact;
Combination(long long N) {
fact = vector<mint>({mint(1)});
invfact = vector<mint>({mint(1)});
fact_initialize(N);
}
void fact_initialize(long long N) {
long long i0 = fact.size();
if (i0 >= N + 1) return;
fact.resize(N + 1);
invfact.resize(N + 1);
for (long long i = i0; i <= N; i++) fact[i] = fact[i - 1] * i;
invfact[N] = (mint)1 / fact[N];
for (long long i = N - 1; i >= i0; i--)
invfact[i] = invfact[i + 1] * (i + 1);
}
mint nCr(long long n, long long r) {
if (n < 0 || r < 0 || r > n) return mint(0);
if (fact.size() < n + 1) fact_initialize(n);
return fact[n] * invfact[r] * invfact[n - r];
}
mint nPr(long long n, long long r) {
if (n < 0 || r < 0 || r > n) return mint(0);
if (fact.size() < n + 1) fact_initialize(n);
return fact[n] * invfact[n - r];
}
};
template <typename T>
struct Matrix {
long long R, C;
vector<T> element;
__inline__ T &at(long long i, long long j) { return element[i * C + j]; }
Matrix(long long R, long long C, vector<T> &element)
: R(R), C(C), element(element) {
assert(element.size() == R * C);
}
Matrix(vector<vector<T>> &_element) {
R = _element.size();
C = _element[0].size();
element.resize(R * C);
for (long long i = 0; i < R; i++)
for (long long j = 0; j < C; j++) element[i * C + j] = _element[i][j];
}
Matrix(long long R, long long C) : R(R), C(C) {
element = vector<T>(R * C, (T)0);
}
Matrix(long long N) : R(N), C(N) {
element = vector<T>(N * N, (T)0);
for (long long i = 0; i < N; i++) element[(N + 1) * i] = (T)1;
}
Matrix() : R(0), C(0) {}
Matrix operator+(Matrix &x) {
assert(R == x.R && C == x.C);
Matrix M(R, C);
for (long long i = 0; i < R * C; i++)
M.element[i] = element[i] + x.element[i];
return M;
}
Matrix operator-(Matrix &x) {
assert(R == x.R && C == x.C);
Matrix M(R, C);
for (long long i = 0; i < R * C; i++)
M.element[i] = element[i] - x.element[i];
return M;
}
Matrix operator*(Matrix &x) {
assert(C == x.R);
Matrix M(R, x.C);
for (long long i = 0; i < R; i++)
for (long long j = 0; j < x.C; j++) {
for (long long k = 0; k < C; k++) M.at(i, j) += at(i, k) * x.at(k, j);
}
return M;
}
Matrix operator*(const T &a) {
Matrix M(R, C);
for (long long i = 0; i < R * C; i++) M.element[i] = element[i] * a;
return M;
}
Matrix operator+=(Matrix &x) { return *this = *this + x; }
Matrix operator-=(Matrix &x) { return *this = *this - x; }
Matrix operator*=(Matrix &x) { return *this = *this * x; }
Matrix operator*=(const T &a) {
for (long long i = 0; i < R * C; i++) element[i] *= a;
return *this;
}
Matrix pow(long long n) {
assert(R == C);
Matrix M(R);
if (n == 0) return M;
long long i0 = 64 - __builtin_clzll(n);
for (long long i = i0 - 1; i >= 0; i--) {
M *= M;
if ((n >> i) & 1) M *= (*this);
}
return M;
}
void Print() {
for (long long i = 0; i < R; i++) {
for (long long j = 0; j < C; j++) cout << element[i * C + j] << " ";
cout << endl;
}
}
Matrix slide() {
Matrix A(R, C);
for (long long i = (0); i < (R); i++)
for (long long j = (0); j < (C); j++) {
long long i0 = i, j0 = j;
if (i0) i0 = i0 % (R - 1) + 1;
if (j0) j0 = j0 % (C - 1) + 1;
A.at(i0, j0) = at(i, j);
}
return A;
}
};
signed main() {
long long n, k;
cin >> n >> k;
vec d;
long long n0 = n;
while (n0) {
d.push_back(n0 % k);
n0 /= k;
}
long long D = ((long long)d.size());
Matrix<mint> A0(k + 1);
for (long long j = (0); j < (k + 1); j++) A0.at(1, j) = 1;
vector<Matrix<mint>> Ms(D);
Ms[0] = A0;
for (long long i = (0); i < (D - 1); i++) {
A0 = Ms[i];
Ms[i + 1] = Matrix<mint>(k + 1);
for (long long j = (0); j < (k); j++) {
Ms[i + 1] = A0 * Ms[i + 1];
A0 = A0.slide();
}
}
Matrix<mint> dp(k + 1, 1);
dp.at(0, 0) = 1;
long long tmp = 0;
for (long long i = (D)-1; i >= (0); i--) {
for (long long j = (0); j < (tmp); j++) Ms[i] = Ms[i].slide();
for (long long j = (0); j < (d[i]); j++) {
dp = Ms[i] * dp;
Ms[i] = Ms[i].slide();
}
tmp = (tmp + d[i]) % k;
}
mint ans = 0;
for (long long j = (0); j < (k + 1); j++) ans += dp.at(0, j);
Out(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 35;
struct Point {
int x, y;
Point() {}
Point(int _x, int _y) : x(_x), y(_y) {}
bool operator==(const Point &b) const { return x == b.x && y == b.y; }
bool operator!=(const Point &b) const { return !(*this == b); }
};
int N, M, ip[MX][MX], op[MX][MX];
Point p(-1, -1), q;
vector<Point> ans;
vector<Point> seq;
int bad[MX][MX];
Point prv[MX][MX];
Point que[MX * MX];
int vst[MX][MX];
int fr, bk;
int dir[8][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
vector<Point> path;
void BFS(Point ed) {
fr = bk = 0;
memset((vst), 0, sizeof(vst));
que[bk++] = p;
vst[p.x][p.y] = 1;
while (fr < bk) {
Point u = que[fr++];
for (int i = 0; i < 8; i++) {
int nx = u.x + dir[i][0];
int ny = u.y + dir[i][1];
if (nx < 1 || ny < 1 || nx > N || ny > M) continue;
if (bad[nx][ny]) continue;
if (q.x == nx && q.y == ny) continue;
if (vst[nx][ny]) continue;
que[bk++] = Point(nx, ny);
prv[nx][ny] = u;
vst[nx][ny] = 1;
}
if (vst[ed.x][ed.y]) break;
}
assert(vst[ed.x][ed.y] == 1);
path.clear();
Point cur = ed;
while (cur != p) {
path.push_back(cur);
cur = prv[cur.x][cur.y];
}
reverse(path.begin(), path.end());
}
void move(Point a) {
if (ans.size()) {
assert(a != ans.back());
}
ans.push_back(a);
swap(ip[a.x][a.y], ip[p.x][p.y]);
p = a;
}
void solve(Point ed) {
q = Point(-1, -1);
for (int i = 1; i <= N && q.x == -1; i++) {
for (int j = 1; j <= M && q.x == -1; j++) {
if (bad[i][j]) continue;
if (p.x == i && p.y == j) continue;
if (ip[i][j] == op[ed.x][ed.y]) q = Point(i, j);
}
}
int dx = 1;
int dy = 1;
if (ed.x < q.x) dx = -1;
if (ed.y < q.y) dy = -1;
while (q != ed) {
if (q.x != ed.x && q.y != ed.y && !bad[q.x + dx][q.y + dy]) {
BFS(Point(q.x + dx, q.y + dy));
} else if (q.x != ed.x && !bad[q.x + dx][q.y]) {
BFS(Point(q.x + dx, q.y));
} else if (q.y != ed.y && !bad[q.x][q.y + dy]) {
BFS(Point(q.x, q.y + dy));
} else {
assert(false);
}
for (auto i : path) move(i);
Point tmp = p;
move(q);
q = tmp;
}
}
void solve_seq() {
for (auto v : seq) {
solve(v);
bad[v.x][v.y] = 1;
}
}
void solve22() {
if (p != Point(1, 1)) {
q = Point(-1, -1);
BFS(Point(1, 1));
for (auto i : path) {
move(i);
}
}
if (ip[2][2] != op[2][2]) {
if (ip[1][2] == op[2][2]) {
move(Point(2, 2));
move(Point(1, 2));
} else if (ip[2][1] == op[2][2]) {
move(Point(2, 2));
move(Point(2, 1));
}
}
if (p != Point(1, 1)) {
move(Point(1, 1));
}
if (ip[1][2] != op[1][2]) {
move(Point(2, 1));
move(Point(1, 2));
}
if (p != Point(1, 1)) {
move(Point(1, 1));
}
}
bool check(Point st, Point ed) {
int dx = 0;
int dy = 0;
if (ed.x < st.x) dx = -1;
if (ed.x > st.x) dx = 1;
if (ed.y < st.y) dy = -1;
if (ed.y > st.y) dy = 1;
int tp[MX][MX];
for (int i = 0; i < MX; i++)
for (int j = 0; j < MX; j++) tp[i][j] = ip[i][j];
ans.clear();
while (st != ed) {
ans.push_back(st);
swap(tp[st.x][st.y], tp[st.x + dx][st.y + dy]);
st.x += dx;
st.y += dy;
}
ans.push_back(ed);
int fail = 0;
for (int i = 1; i <= N && !fail; i++)
for (int j = 1; j <= M && !fail; j++)
if (tp[i][j] != op[i][j]) fail = 1;
return !fail;
}
int main() {
int c1[MX * MX] = {0};
int c2[MX * MX] = {0};
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
scanf("%d", &ip[i][j]);
c1[ip[i][j]]++;
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
scanf("%d", &op[i][j]);
c2[op[i][j]]++;
}
}
for (int i = 1; i < MX * MX; i++) {
if (c1[i] != c2[i]) {
puts("-1");
return 0;
}
}
if (N == 1 || M == 1) {
vector<Point> pt;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) pt.push_back(Point(i, j));
int n = pt.size();
int ok = 0;
for (int i = 0; i < n && !ok; i++) {
for (int j = 0; j < n && !ok; j++) {
if (i == j) continue;
if (check(pt[i], pt[j])) {
ok = 1;
}
}
}
if (ok) {
printf("%d\n", (int)ans.size() - 1);
for (auto i : ans) printf("%d %d\n", i.x, i.y);
} else {
puts("-1");
}
} else {
p = Point(-1, -1);
for (int i = 1; i <= N && p.x == -1; i++) {
for (int j = 1; j <= M && p.x == -1; j++) {
if (ip[i][j] == op[1][1]) {
p = Point(i, j);
}
}
}
int x = p.x;
int y = p.y;
for (int j = M; j > 2; j--) {
for (int i = N; i >= 1; i--) {
seq.push_back(Point(i, j));
}
}
for (int i = N; i > 2; i--) {
seq.push_back(Point(i, 2));
seq.push_back(Point(i, 1));
}
memset((bad), 0, sizeof(bad));
solve_seq();
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (i > 2 && j > 2 && ip[i][j] != op[i][j]) {
assert(false);
}
}
}
solve22();
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (ip[i][j] != op[i][j]) {
assert(false);
}
}
}
assert(ans.size() <= 1000000);
printf("%d\n", (int)ans.size());
printf("%d %d\n", x, y);
for (auto i : ans) printf("%d %d\n", i.x, i.y);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int intf = 0x3f3f3f3f;
const int N = 5e6 + 2;
bool np[N];
int prime[N], pi[N];
int cnt = 0;
int getprime() {
np[0] = np[1] = true;
pi[0] = pi[1] = 0;
for (int i = 2; i < N; ++i) {
if (!np[i]) prime[++cnt] = i;
pi[i] = cnt;
for (int j = 1; j <= cnt && i * prime[j] < N; ++j) {
np[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
return cnt;
}
const int M = 7;
const int PM = 2 * 3 * 5 * 7 * 11 * 13 * 17;
int phi[PM + 1][M + 1], sz[M + 1];
void init() {
getprime();
sz[0] = 1;
for (int i = 0; i <= PM; ++i) phi[i][0] = i;
for (int i = 1; i <= M; ++i) {
sz[i] = prime[i] * sz[i - 1];
for (int j = 1; j <= PM; ++j)
phi[j][i] = phi[j][i - 1] - phi[j / prime[i]][i - 1];
}
}
int sqrt2(long long x) {
long long r = (long long)sqrt(x - 0.1);
while (r * r <= x) ++r;
return int(r - 1);
}
int sqrt3(long long x) {
long long r = (long long)cbrt(x - 0.1);
while (r * r * r <= x) ++r;
return int(r - 1);
}
long long getphi(long long x, int s) {
if (s == 0) return x;
if (s <= M) return phi[x % sz[s]][s] + (x / sz[s]) * phi[sz[s]][s];
if (x <= prime[s] * prime[s]) return pi[x] - s + 1;
if (x <= prime[s] * prime[s] * prime[s] && x < N) {
int s2x = pi[sqrt2(x)];
long long ans = pi[x] - (s2x + s - 2) * (s2x - s + 1) / 2;
for (int i = s + 1; i <= s2x; ++i) ans += pi[x / prime[i]];
return ans;
}
return getphi(x, s - 1) - getphi(x / prime[s], s - 1);
}
long long getpi(long long x) {
if (x < N) return pi[x];
long long ans = getphi(x, pi[sqrt3(x)]) + pi[sqrt3(x)] - 1;
for (int i = pi[sqrt3(x)] + 1, ed = pi[sqrt2(x)]; i <= ed; ++i)
ans -= getpi(x / prime[i]) - i + 1;
return ans;
}
long long lehmer_pi(long long x) {
if (x < N) return pi[x];
int a = (int)lehmer_pi(sqrt2(sqrt2(x)));
int b = (int)lehmer_pi(sqrt2(x));
int c = (int)lehmer_pi(sqrt3(x));
long long sum = getphi(x, a) + (long long)(b + a - 2) * (b - a + 1) / 2;
for (int i = a + 1; i <= b; i++) {
long long w = x / prime[i];
sum -= lehmer_pi(w);
if (i > c) continue;
long long lim = lehmer_pi(sqrt2(w));
for (int j = i; j <= lim; j++) sum -= lehmer_pi(w / prime[j]) - (j - 1);
}
return sum;
}
int main() {
init();
long long n;
cin >> n;
long long sum = 0;
sum += lehmer_pi(1ll * cbrt(n * 1.0));
for (int i = 1; 1ll * prime[i] * prime[i] <= n; i++) {
long long b = n / prime[i];
sum += lehmer_pi(b) - i;
}
cout << sum << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int N = 3e5, M = N;
void solve() {
long long n;
cin >> n;
vector<long long> arr(n);
for (int i = 0; i < (n); i++) cin >> arr[i];
string s;
cin >> s;
vector<long long> prefix(n + 1, 0);
for (int i = 0; i < (n); i++) prefix[i + 1] = prefix[i] + arr[i];
long long ans = 0, l = 0;
for (int i = (n - 1); i >= (0); i--) {
if (s[i] == '1') {
ans = max(ans, l + prefix[i]);
l += arr[i];
}
}
cout << max(ans, l) << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int a[500000 + 10], sum[500000 + 10];
map<long long int, map<long long int, int> > s;
map<long long int, long long int> ind;
int main() {
long long int n, i, j, ts = 0;
cin >> n;
sum[0] = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
s[sum[i]][i] = 1;
ind[i] = sum[i];
}
ts = sum[n];
if (sum[n] % 3 != 0) {
cout << 0;
return 0;
}
long long int cnt = 0;
for (i = 1; i <= n; i++) {
long long int fs = sum[i];
s[fs].erase(i);
long long int c = s[fs + fs].size();
if (c > 0 && ind[n] == fs + fs) c--;
if (ind[n] == fs + fs + fs) {
cnt = cnt + c;
}
}
cout << cnt;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const long double PI = 3.14159265358979323846;
const long long MOD = 998244353;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
srand(time(0));
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s1, s2;
cin >> s1 >> s2;
set<int> f, s;
for (int i = 0; i < n; i++) {
if (s1[i] == '0' && s2[i] == '1') {
f.insert(i);
}
if (s1[i] == '1' && s2[i] == '0') {
s.insert(i);
}
}
if (s.size() != f.size()) {
cout << -1;
return 0;
}
int cnt = 0;
while (f.size()) {
int last, from;
if (*f.begin() > *s.begin()) {
swap(f, s);
}
int cur = *f.begin();
f.erase(f.begin());
from = 0;
while (true) {
from ^= 1;
if (from) {
auto it = s.lower_bound(cur);
if (it == s.end()) break;
cur = *it;
s.erase(it);
} else {
auto it = f.lower_bound(cur);
if (it == f.end()) break;
cur = *it;
f.erase(it);
}
}
if (from == 1) {
f.insert(cur);
}
cnt++;
}
cout << cnt;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e;
cin >> a >> b >> c >> d >> e;
int e1 = a * (b) + 2 * d;
int e2 = a * (c) + 2 * e;
if (e1 < e2) {
cout << "First";
} else if (e1 > e2) {
cout << "Second";
} else {
cout << "Friendship";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2111;
int f[N][N], o[N + 1];
char s[N], p[N];
int main() {
scanf("%s%s", s, p);
int ls = strlen(s), lp = strlen(p);
for (int i = 0; i < ls; ++i)
for (int j = 0; j <= i; ++j) {
int k = j % lp, l = (j + 1) / lp, &x = f[i + 1][j + 1] = N,
y = i + 1 - l * lp;
if (i >= j + 1) x = f[i][j + 1] + !!(k + 1 - lp);
if (s[i] == p[k]) x = min(x, f[i][j]);
if (i + 1 == ls)
for (; y >= x; --y) o[y] = max(o[y], l);
}
for (int i = 0; i <= ls; ++i) printf("%d ", o[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const double PI = 3.141592653589793238463;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int x;
cin >> x;
int y[x + 1], a[x + 1];
vector<pair<int, int>> ans;
for (int i = 1; i <= x; i++) {
cin >> y[i];
}
for (int i = 1; i <= x; i++) cin >> a[i];
for (int i = 1; i <= x; i++) {
for (int j = i; j <= x; j++) {
if (y[i] == a[j]) {
int k = j;
while (k > i) {
swap(a[k - 1], a[k]);
ans.push_back({k - 1, k});
k--;
}
break;
}
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[200001];
int v[200002];
int main() {
int n, m, i, j, a;
char c;
c = getchar();
n = 0;
while (c != '\n') {
s[++n] = c;
c = getchar();
}
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &a);
v[a] += 1;
v[n - a + 2] -= 1;
}
for (i = 1; i <= n; i++) v[i] += v[i - 1];
char aux;
for (i = 1; i <= n / 2; i++) {
if (v[i] % 2 == 1) {
aux = s[i];
s[i] = s[n - i + 1];
s[n - i + 1] = aux;
}
}
for (i = 1; i <= n; i++) printf("%c", s[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<double, double> > v;
const double pi = 3.1415926535897932384626433832795;
const double eps = 0.00000001;
double cosa, sina;
double w, h, a;
double x, y;
double fun_y(pair<double, double> p1, pair<double, double> p2, double x) {
return (x * (p1.second - p2.second) - p2.first * (p1.second - p2.second) +
p2.second * (p1.first - p2.first)) /
(p1.first - p2.first);
}
double fun_x(pair<double, double> p1, pair<double, double> p2, double y) {
return (y * (p1.first - p2.first) - p2.second * (p1.first - p2.first) +
p2.first * (p1.second - p2.second)) /
(p1.second - p2.second);
}
bool inside(double xx, double yy) {
return (xx >= -x - eps && xx <= x + eps && yy >= -y - eps && yy <= y + eps);
}
void per(pair<double, double> p1, pair<double, double> p2) {
double xx, yy;
xx = x;
yy = fun_y(p1, p2, xx);
if (inside(xx, yy)) v.push_back(pair<double, double>(xx, yy));
xx = -x;
yy = fun_y(p1, p2, xx);
if (inside(xx, yy)) v.push_back(pair<double, double>(xx, yy));
yy = y;
xx = fun_x(p1, p2, yy);
if (inside(xx, yy)) v.push_back(pair<double, double>(xx, yy));
yy = -y;
xx = fun_x(p1, p2, yy);
if (inside(xx, yy)) v.push_back(pair<double, double>(xx, yy));
}
void line(double x, double y, double xx, double yy) {
double x1 = x * cosa - y * sina;
double y1 = x * sina + y * cosa;
double x2 = xx * cosa - yy * sina;
double y2 = xx * sina + yy * cosa;
per(pair<double, double>(x1, y1), pair<double, double>(x2, y2));
}
double sum(int num) {
double dx = v[num].first - v[0].first;
double dy = v[num].second - v[0].second;
double d2x = v[num + 1].first - v[0].first;
double d2y = v[num + 1].second - v[0].second;
return fabs(dx * d2y - dy * d2x);
}
bool cmp(const pair<double, double> &p1, const pair<double, double> &p2) {
return atan2(p1.second, p1.first) < atan2(p2.second, p2.first);
}
void fun() {
cin >> w >> h >> a;
a = a / 180.0 * pi;
cosa = cos(a);
sina = sin(a);
x = w / 2.0;
y = h / 2.0;
if (a == 0.0 || a == 180.0) {
printf("%lf", w * h);
return;
}
if (a == 90.0) {
printf("%lf", min(w, h) * min(w, h));
return;
}
line(+x, +y, -x, +y);
line(+x, +y, +x, -y);
line(-x, +y, -x, -y);
line(-x, -y, +x, -y);
sort(v.begin(), v.end(), cmp);
double S = 0;
for (int i = 1; i < int(v.size()) - 1; ++i) {
S += sum(i);
}
printf("%lf", S / 2.0);
}
int main() {
fun();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int dp1[15], dp2[15], op1[15], op2[15];
int main() {
int t;
cin >> t;
while (t--) {
for (int i = 0; i < 6; i++) dp1[i] = 0, dp2[i] = 0, op1[i] = 0, op2[i] = 0;
string s;
cin >> s;
for (int p = 0; p < s.size(); p++) {
if (p % 2 == 0) {
int i = (p + 1) / 2;
if (s[p] == '1')
dp1[i + 1] += dp1[i] + 1, dp2[i + 1] += dp2[i] + 1;
else if (s[p] == '0')
dp1[i + 1] = dp1[i], dp2[i + 1] = dp2[i];
else
dp1[i + 1] += dp1[i] + 1, dp2[i + 1] = dp2[i];
} else {
int i = p / 2;
if (s[p] == '1')
op1[i + 1] += op1[i] + 1, op2[i + 1] += op2[i] + 1;
else if (s[p] == '0')
op1[i + 1] = op1[i], op2[i + 1] = op2[i];
else
op1[i + 1] += op1[i] + 1, op2[i + 1] = op2[i];
}
}
int ma = 10;
for (int i = 1; i <= 5; i++) {
if (dp1[i] - op2[i - 1] > 5 - i + 1)
ma = min(ma, 2 * i - 1);
else if (dp1[i] - op2[i] > 5 - i)
ma = min(ma, 2 * i);
if (op1[i - 1] - dp2[i] > 5 - i)
ma = min(ma, 2 * i - 1);
else if (op1[i] - dp2[i] > 5 - i)
ma = min(ma, 2 * i);
}
printf("%d\n", ma);
}
}
| 2 |
#include <bits/stdc++.h>
long long int fre[1000001] = {0};
using namespace std;
int main() {
long long int k, temp = 0, con = 0;
string s;
cin >> k >> s;
fre[0] = 1;
for (char c : s) {
temp += (c - '0');
if (temp - k >= 0) {
con += fre[temp - k];
}
fre[temp]++;
}
for (int i = 0; i <= temp; i++) {
}
cout << con << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T first, T second) {
while (second > 0) {
first %= second;
swap(first, second);
}
return first;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
template <typename T>
inline void input(T &a) {
static int ed;
a = 0;
while (!isdigit(ed = getchar()) && ed != '-') {
}
char neg = 0;
if (ed == '-') {
neg = 1;
ed = getchar();
}
while (isdigit(ed)) {
a = 10 * a + ed - '0';
ed = getchar();
}
if (neg) a = -a;
}
template <typename T = int>
inline T nxt() {
T res;
input(res);
return res;
}
mt19937 generator;
bool check(int v) {
if (v < 2) return false;
for (int i = 2; i * i <= v; ++i) {
if (v % i == 0) {
return false;
}
}
return true;
}
long long pw(long long a, long long n, long long m) {
long long res = 1;
while (n) {
if (n & 1ll) {
res = res * a % m;
}
a = a * a % m;
n >>= 1;
}
return res;
}
void pre() {}
string min_cyclic_shift(string s) {
s += s;
int n = (int)s.length();
int i = 0, ans = 0;
while (i < n / 2) {
ans = i;
int j = i + 1, k = i;
while (j < n && s[k] <= s[j]) {
if (s[k] < s[j])
k = i;
else
++k;
++j;
}
while (i <= k) i += j - k;
}
return s.substr(ans, n / 2);
}
void solve(int test) {
int n = nxt();
vector<int> a;
for (int i = 0; i < n; ++i) {
int first = nxt();
if (first != 0) {
a.push_back(first);
}
}
vector<int> b;
for (int i = 0; i < n; ++i) {
int first = nxt();
if (first != 0) {
b.push_back(first);
}
}
auto pos1 = min_element((a).begin(), (a).end());
auto pos2 = min_element((b).begin(), (b).end());
rotate(a.begin(), pos1, a.end());
rotate(b.begin(), pos2, b.end());
cout << (a == b ? "YES" : "NO") << endl;
}
int main(int argc, char **argv) {
int t = 1;
pre();
int c = 0;
while (t--) {
solve(++c);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[222222];
int main() {
int n, k;
scanf("%d %d", &n, &k);
scanf("%s", s);
int ans = 0, m = strlen(s);
for (int h = 0; h < 26; h++) {
int a = 0;
for (int j = 0, i = 0; j < m; j++) {
if (s[j] == 'a' + h) {
i++;
if (i == k) {
a++;
i = 0;
}
} else
i = 0;
}
if (a > ans) ans = a;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int main() {
int s, k;
long long n;
scanf("%d", &s);
for (int i = 0; i < s; i++) {
scanf("%d", &k);
n = k;
if ((n + 1) % 2 == 1)
printf("%I64d\n", 4 * n + 1);
else if ((n + 1) / 2 % 2 == 1)
printf("%I64d\n", 2 * n + 1);
else
printf("%I64d\n", n + 1);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, i;
cin >> n;
long long int a[n];
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
long long int g = 1, prev = 0, temp = 0;
sort(a, a + n);
for (i = 0; i < n; i++) {
if (a[i] != prev) {
m[a[i]] += g;
prev = a[i];
g = m[a[i]];
}
}
for (i = n - 1; i >= 0; i--) {
if (m[a[i]] > a[i]) {
temp = 1;
break;
}
}
if (temp)
cout << m[a[i]] << endl;
else
cout << 1 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long ar[100005], pre[100005], pp[100005];
int N, Q;
long long calc(int l, int r, long long laz) {
return ((r - l + 1) * laz + (r <= 0 ? 0 : pp[r - 1]) -
(l <= 1 ? 0 : pp[l - 2]));
}
class SegTree {
private:
long long lazy[4 * 100005];
long long tree[4 * 100005];
bool active[4 * 100005];
public:
SegTree(long long N) {}
long long comb(long long a, long long b) { return (a + b); }
long long get_val(long long l, long long r, long long l1, long long r1,
long long ind) {
if (l1 > r || r1 < l) {
return (0);
}
if (l <= l1 && r1 <= r) {
return (tree[ind]);
}
if (active[ind]) {
lazy[2 * ind] = lazy[ind];
tree[2 * ind] = calc(l1, (r1 + l1) / 2, lazy[ind]);
active[2 * ind] = true;
lazy[2 * ind + 1] = lazy[ind];
tree[2 * ind + 1] = calc((r1 + l1) / 2 + 1, r1, lazy[ind]);
active[2 * ind + 1] = true;
active[ind] = false;
}
long long leftS = get_val(l, r, l1, (r1 + l1) / 2, (2 * ind));
long long rightS = get_val(l, r, (r1 + l1) / 2 + 1, r1, 2 * ind + 1);
return (comb(leftS, rightS));
}
long long query(long long a, long long b) {
return (get_val(a, b, 0, 100005, 1));
}
void change_val(long long l, long long r, long long newVal, long long ind,
long long a, long long b) {
if (l > b || r < a) {
return;
}
if (a <= l && r <= b) {
lazy[ind] = newVal;
tree[ind] = calc(l, r, newVal);
active[ind] = true;
return;
}
if (active[ind]) {
lazy[2 * ind] = lazy[ind];
tree[2 * ind] = calc(l, (r + l) / 2, lazy[ind]);
active[2 * ind] = true;
lazy[2 * ind + 1] = lazy[ind];
tree[2 * ind + 1] = calc((r + l) / 2 + 1, r, lazy[ind]);
active[2 * ind + 1] = true;
active[ind] = false;
}
change_val(l, (r + l) / 2, newVal, 2 * ind, a, b);
change_val((r + l) / 2 + 1, r, newVal, 2 * ind + 1, a, b);
tree[ind] = comb(tree[2 * ind], tree[2 * ind + 1]);
}
void update(long long a, long long b, long long val) {
change_val(0, 100005, val, 1, a, b);
}
};
int main() {
cin >> N;
SegTree seg = SegTree(100005);
for (int i = 0; i < N; i++) {
cin >> ar[i];
seg.update(i, i, ar[i]);
}
int x;
for (int i = 0; i < N - 1; i++) {
cin >> x;
if (i == 0)
pre[i] = x;
else
pre[i] = pre[i - 1] + x;
}
for (int i = 0; i < N - 1; i++) {
if (i == 0)
pp[i] = pre[i];
else
pp[i] = pp[i - 1] + pre[i];
}
cin >> Q;
char c;
int a, b;
for (int i = 0; i < Q; i++) {
cin >> c >> a >> b;
a--;
if (c == 's')
cout << seg.query(a, b - 1) << endl;
else {
long long cur = seg.query(a, a);
int low = a;
int hi = N;
while (low + 1 < hi) {
int mid = (low + hi) / 2;
if (cur + b - (a == 0 ? 0 : pre[a - 1]) +
(mid == 0 ? 0 : pre[mid - 1]) >
seg.query(mid, mid))
low = mid;
else
hi = mid;
}
seg.update(a, low, cur + b - (a == 0 ? 0 : pre[a - 1]));
}
}
return (0);
}
| 7 |
#include <bits/stdc++.h>
int mypow(int n, int m) {
int sum = 1, i;
for (i = 0; i < m; i++) {
sum *= n;
}
return sum;
}
int main() {
int num[100][2], i, n, k, j;
float d, t;
d = t = 0;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
scanf("%d", &num[i][j]);
}
}
for (i = 0; i < n - 1; i++) {
d += sqrt((mypow(num[i][0] - num[i + 1][0], 2)) +
(mypow(num[i][1] - num[i + 1][1], 2)));
}
t = d / 50;
printf("%f", k * t);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[150005], b[10], n, k, q, i, j, cnt, s, f;
long long cmt;
int main() {
cin >> n >> k >> q;
for (i = 0; i < n; i++) cin >> a[i];
while (q--) {
cin >> cnt >> s;
s--;
if (cnt == 1) {
for (i = 0; i < k; i++) {
if (i >= cmt || a[s] > a[b[i]]) break;
}
if (i < k) {
for (j = k - 1; j > i; j--) {
b[j] = b[j - 1];
}
b[i] = s;
}
cmt++;
} else {
f = 0;
for (i = 0; i < cmt && i < k; i++) {
if (b[i] == s) {
f = 1;
break;
}
}
if (f)
printf("YES\n");
else
printf("NO\n");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int>> a(2 * n);
for (int i = 0; i < 2 * n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
long long ans = 0, idx1 = 0, idx2 = 0;
for (int i = 0; i < n; i++) {
int idx_1 = a[i * 2].second, idx_2 = a[i * 2 + 1].second;
if (abs(idx1 - idx_1) + abs(idx2 - idx_2) <
abs(idx1 - idx_2) + abs(idx2 - idx_1)) {
ans += abs(idx1 - idx_1) + abs(idx2 - idx_2);
idx1 = idx_1;
idx2 = idx_2;
} else {
ans += abs(idx1 - idx_2) + abs(idx2 - idx_1);
idx1 = idx_2;
idx2 = idx_1;
}
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool SbS(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long SUMD(long long n);
long long BS(vector<long long> &PS, long long s, long long e, long long ser);
long long MI(long long a, long long m);
bool P[2002LL];
void Sieve(int n = 100005);
int nCrModp(int n, int r, int p);
vector<long long> PF(long long n);
long long Powb(long long b, long long n);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long q = 1;
cin >> q;
while (q--) {
long long n, m, k, i, j, l, r, a, t, b, c, u, v, w, p;
cin >> n >> m;
vector<long long> Ind(3 * n + 1);
vector<long long> M;
for (i = 1; i <= m; i++) {
cin >> u >> v;
if (Ind[u] == 0 and Ind[v] == 0) {
M.push_back(i);
Ind[u] = 1;
Ind[v] = 1;
}
}
if (M.size() >= n) {
cout << "Matching"
<< "\n";
for (int i = 0; i < n; i++) {
cout << M[i] << " ";
};
cout << "\n";
} else {
cout << "IndSet"
<< "\n";
for (i = 1, j = 1; i <= 3 * n, j <= n; i++) {
if (Ind[i] == 0) {
cout << i << " ";
j++;
}
}
cout << "\n";
}
}
return 0;
}
long long Powb(long long b, long long n) {
if (n == 0) return 1LL;
if (n == 1) return b;
long long temp = Powb(b, n / 2);
if (n % 2 == 0) {
return (temp * temp) % 1000000007;
} else {
return (b * ((temp * temp) % 1000000007)) % 1000000007;
}
}
long long SUMD(long long n) {
long long sum = 0;
while (n > 0) {
sum += n % 10;
n = n / 10;
}
return sum;
}
long long BS(vector<long long> &PS, long long s, long long e, long long ser) {
if (s > e) return s;
long long mid = (s + e) / 2;
if (PS[mid] == ser) {
return mid;
} else if (PS[mid] > ser) {
return BS(PS, s, mid - 1, ser);
} else
return BS(PS, mid + 1, e, ser);
}
long long MI(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
void Sieve(int n) {
memset(P, true, sizeof(P));
P[0] = false;
P[1] = false;
for (long long i = 2; i * i <= n; i++) {
if (P[i]) {
for (long long j = i * i; j <= n; j += i) {
P[j] = false;
}
}
}
}
int nCrModp(int n, int r, int p) {
int C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
vector<long long> PF(long long n) {
vector<long long> pf;
if (n % 2 == 0) {
pf.push_back(2LL);
n = n / 2;
while (n % 2 == 0) n = n / 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
long long flag = 1;
while (n % i == 0) {
if (flag) {
pf.push_back(i);
flag = 0;
}
n = n / i;
}
}
if (n > 2) pf.push_back(n);
return pf;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
struct element {
long long health;
long long damage;
long long diff;
};
bool comp(element X, element Y) { return X.diff > Y.diff; }
int N, a, b;
long long power[25];
element A[MAXN];
long long cum[MAXN];
long long ret;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
power[0] = 1;
for (int i = 1; i <= 20; i++) power[i] = 2 * power[i - 1];
cin >> N >> a >> b;
long long ans = 0;
for (int i = 0; i < N; i++) {
cin >> A[i].health >> A[i].damage;
A[i].diff = A[i].health - A[i].damage;
ans += A[i].damage;
}
sort(A, A + N, comp);
cum[0] = max(0LL, A[0].diff);
for (int i = 1; i < N; i++) {
cum[i] = max(cum[i - 1], A[i].diff + cum[i - 1]);
}
ret = ans;
for (int i = 0; i < N; i++) {
if (b == 0) continue;
long long new_health = power[a] * A[i].health;
if (b >= 1) {
long long new_ans = ans - A[i].damage + new_health;
int new_b = b - 1;
if (new_b >= 1) {
if (new_b <= i)
new_ans += cum[new_b - 1];
else {
int rem = new_b - i;
new_ans = new_ans + cum[i - 1] + (cum[min(i + rem, N - 1)] - cum[i]);
}
}
ret = max(ret, new_ans);
}
}
cout << ret << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
map<int, bool> vis;
vector<int> raw;
int ans[114514], M, s;
inline int idxLB(int x) {
return lower_bound(raw.begin(), raw.end(), x) - raw.begin();
}
inline int idxUB(int x) {
return upper_bound(raw.begin(), raw.end(), x) - raw.begin();
}
bool judge(int d) {
int idx = 0;
for (int i = 1; i <= 3; i++) {
idx = idxUB(raw[idx] + d);
ans[i] = idx;
if (idx == s) return 1;
}
return 0;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int tmp;
scanf("%d", &tmp);
if (!vis[tmp]) {
vis[tmp] = 1;
raw.push_back(tmp);
}
}
sort(raw.begin(), raw.end());
s = raw.size();
int L = 0, R = INF;
while (L <= R) {
M = L + (R - L) / 2;
if (judge(M))
R = M - 1;
else
L = M + 1;
}
if (judge(M) ? 0 : M++) judge(M);
printf("%.6lf\n", M / 2.0);
for (int i = 0; i <= 2; i++)
printf("%.6lf ", raw[ans[i] >= s ? 0 : ans[i]] + (M / 2.0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
char mp[1010][1010];
int vis[1010][1010][3][5];
int n, m, ans;
int x, y;
void location() {
int i, j;
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (mp[i][j] == 'S') {
x = i;
y = j;
}
}
}
}
void dfs(int x, int y, int turn, int d) {
if (x < 0 || x >= n || y < 0 || y >= m || turn > 2 ||
vis[x][y][turn][d] == 1 || mp[x][y] == '*' || ans == 1)
return;
vis[x][y][turn][d] = 1;
if (mp[x][y] == 'T') {
ans = 1;
return;
}
if (d == 0 || d == 1)
dfs(x - 1, y, turn, 1);
else if (d == 3 || d == 4)
dfs(x - 1, y, turn + 1, 1);
if (d == 0 || d == 2)
dfs(x + 1, y, turn, 2);
else if (d == 3 || d == 4)
dfs(x + 1, y, turn + 1, 2);
if (d == 0 || d == 3)
dfs(x, y - 1, turn, 3);
else if (d == 1 || d == 2)
dfs(x, y - 1, turn + 1, 3);
if (d == 0 || d == 4)
dfs(x, y + 1, turn, 4);
else if (d == 1 || d == 2)
dfs(x, y + 1, turn + 1, 4);
}
int main() {
int i;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 0; i < n; i++) scanf("%s", mp[i]);
location();
ans = 0;
dfs(x, y, 0, 0);
if (ans)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ar[500005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &ar[i]);
}
string s;
cin >> s;
long long gain = 0;
long long loss = 0;
long long bob = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'B') {
bob += ar[i];
}
}
long long ma = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'A') {
gain += ar[i];
} else {
loss += ar[i];
}
ma = max(ma, gain - loss);
}
gain = 0;
loss = 0;
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'A') {
gain += ar[i];
} else {
loss += ar[i];
}
ma = max(ma, gain - loss);
}
bob += ma;
printf("%lld", bob);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long x[100001];
int main() {
long long n, k, s, del, ost, a = 1;
cin >> n >> k >> s;
if ((n - 1) * k < s || k > s) {
cout << "NO";
return 0;
}
cout << "YES" << endl;
del = s / k;
ost = s % k;
int t;
for (int i = 0; i < k; i++) {
if (ost) {
t = 1;
ost--;
} else
t = 0;
if (i % 2 == 0)
a += del + t;
else
a -= (del + t);
cout << a << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, min = INT_MAX, count = 0;
vector<int> v;
cin >> n;
for (size_t i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
if (min > a) min = a;
}
for (size_t i = 0; i < v.size(); i++) {
if (v[i] == min) {
count++;
a = i;
}
}
if (count == 1) {
cout << a + 1 << endl;
} else {
cout << "Still Rozdil" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
using vll = vector<long long>;
using vii = vector<pair<int, int>>;
int digits(int n) {
if (n == 0) return 1;
int r = 0;
while (n > 0) {
n /= 7;
++r;
}
return r;
}
bool distinct(const vi& v) {
vector<bool> flag(7);
for (int x : v) {
if (flag[x]) return false;
flag[x] = true;
}
return true;
}
bool inc(vi& v) {
for (int i = v.size() - 1; i >= 0; i--) {
if (++v[i] == 7)
v[i] = 0;
else
return true;
}
return false;
}
int main() {
int n, m;
cin >> n >> m;
int a = digits(n - 1);
int b = digits(m - 1);
int k = a + b;
if (k > 7) {
puts("0");
return 0;
}
vi d(k);
int answer = 0;
do {
int x = 0, y = 0;
for (int i = 0; i < a; i++) x = x * 7 + d[i];
for (int i = a; i < k; i++) y = y * 7 + d[i];
if (x < n && y < m && distinct(d)) ++answer;
} while (inc(d));
printf("%d\n", answer);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> we;
int main() {
int n;
cin >> n;
string x;
cin >> x;
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int b = x[i];
we[b]++;
}
int c = 'a';
while (c != 'z' + 1) {
v.push_back(make_pair(we[c], c));
c++;
}
string sum;
for (int i = 0; i < v.size(); i++) {
int a = v[i].first;
char c = v[i].second;
while (a--) sum += c;
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 201 * 1001;
struct rct {
long long x1, y1, x2, y2;
} rect[MAXN];
struct qury {
long long s, e, val;
};
long long n, k;
long long cnt[4 * MAXN], mn[4 * MAXN], lazy[4 * MAXN];
vector<long long> vx, vy;
void build(long long s, long long e, long long ind) {
if (e - s < 2) {
cnt[ind] = vy[e] - vy[s];
return;
}
long long mid = (s + e) / 2;
build(s, mid, 2 * ind);
build(mid, e, 2 * ind + 1);
cnt[ind] = cnt[2 * ind] + cnt[2 * ind + 1];
}
void shift(long long ind) {
mn[2 * ind] += lazy[ind];
mn[2 * ind + 1] += lazy[ind];
lazy[2 * ind + 1] += lazy[ind];
lazy[2 * ind] += lazy[ind];
lazy[ind] = 0;
return;
}
void add(long long l, long long r, long long val, long long s, long long e,
long long ind) {
if (l <= s && e <= r) {
mn[ind] += val;
lazy[ind] += val;
return;
}
if (e <= l || r <= s) return;
shift(ind);
long long mid = (s + e) / 2;
add(l, r, val, s, mid, 2 * ind);
add(l, r, val, mid, e, 2 * ind + 1);
mn[ind] = min(mn[2 * ind], mn[2 * ind + 1]);
cnt[ind] = (mn[ind] == mn[2 * ind] ? cnt[2 * ind] : 0);
cnt[ind] += (mn[ind] == mn[2 * ind + 1] ? cnt[2 * ind + 1] : 0);
}
vector<qury> query[MAXN];
long long solve() {
vx.clear();
vy.clear();
memset(mn, 0, sizeof mn);
memset(lazy, 0, sizeof lazy);
for (long long i = 0; i < n; i++) {
if (rect[i].x2 < rect[i].x1 || rect[i].y2 < rect[i].y1) continue;
vx.push_back(rect[i].x1);
vx.push_back(rect[i].x2 + 1);
vy.push_back(rect[i].y2 + 1);
vy.push_back(rect[i].y1);
}
sort(vx.begin(), vx.end());
sort(vy.begin(), vy.end());
vx.resize(unique(vx.begin(), vx.end()) - vx.begin());
vy.resize(unique(vy.begin(), vy.end()) - vy.begin());
for (long long i = 0; i < MAXN; i++) query[i].clear();
for (long long i = 0; i < n; i++) {
if (rect[i].x2 < rect[i].x1 || rect[i].y2 < rect[i].y1) continue;
rct a;
a.x1 = lower_bound(vx.begin(), vx.end(), rect[i].x1) - vx.begin();
a.x2 = lower_bound(vx.begin(), vx.end(), rect[i].x2 + 1) - vx.begin();
a.y1 = lower_bound(vy.begin(), vy.end(), rect[i].y1) - vy.begin();
a.y2 = lower_bound(vy.begin(), vy.end(), rect[i].y2 + 1) - vy.begin();
query[a.x1].push_back({a.y1, a.y2, 1});
query[a.x2].push_back({a.y1, a.y2, -1});
}
if (!vy.size() || !vx.size()) return -1;
long long m = vx.size(), k = vy.size() - 1;
build(0, k, 1);
long long ans = 0;
long long sz = vy.back() - vy[0];
for (long long i = 0; i < m - 1; i++) {
for (auto u : query[i]) {
add(u.s, u.e, u.val, 0, k, 1);
}
long long x;
if (mn[1] > 0)
x = sz;
else
x = sz - cnt[1];
if (i < m) ans += ((vx[i + 1] - vx[i]) * x);
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin >> n >> n >> k;
for (long long i = 0; i < n; i++)
cin >> rect[i].x1 >> rect[i].y1 >> rect[i].x2 >> rect[i].y2;
while (k) {
long long x = solve();
if (x == -1) break;
if (x & 1) return cout << "Hamed", 0;
for (long long i = 0; i < n; i++) {
rect[i].y2 /= 2;
rect[i].x2 /= 2;
rect[i].y1 = (rect[i].y1 + 1) / 2;
rect[i].x1 = (rect[i].x1 + 1) / 2;
}
k /= 2;
}
cout << "Malek";
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
int ans;
int main() {
scanf("%d", &n);
for (int t, i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%d", &t);
if (i == j) {
ans += t;
}
}
}
scanf("%d", &q);
for (int a, i = 0; i < q; ++i) {
scanf("%d", &a);
if (a == 1 || a == 2) {
scanf("%d", &a);
++ans;
} else {
printf("%d", ans % 2);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int min(int _a, int _b) { return _a < _b ? _a : _b; }
inline int max(int _a, int _b) { return _a > _b ? _a : _b; }
template <class T>
inline void rd(T &_a) {
int _f = 0, _ch = getchar();
_a = 0;
while (_ch < '0' || _ch > '9') {
if (_ch == '-') _f = 1;
_ch = getchar();
}
while (_ch >= '0' && _ch <= '9') {
_a = (_a << 1) + (_a << 3) + _ch - '0';
_ch = getchar();
}
if (_f) _a = -_a;
}
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
int c[300005], p[300005];
priority_queue<pair<int, int> > q;
int main() {
int n, k;
long long ans = 0;
rd(n);
rd(k);
for (int i = 1; i <= n; i++) rd(c[i]);
for (int i = 1; i <= k; i++) q.push(make_pair(c[i], i));
for (int i = k + 1; i <= k + n; i++) {
if (i <= n) q.push(make_pair(c[i], i));
pair<int, int> u = q.top();
q.pop();
p[u.second] = i;
ans += (long long)(i - u.second) * u.first;
}
printf("%I64d\n", ans);
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, sq;
vector<int> S[100005], heavy_id;
vector<pair<long long, long long> > link[1000005];
long long up[100005], ara[100005], sum[100005];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%lld", &ara[i]);
sq = sqrt(n);
for (int i = 1; i <= m; i++) {
int c, k;
scanf("%d", &k);
while (k--) {
scanf("%d", &c);
sum[i] += ara[c];
S[i].push_back(c);
}
sort(S[i].begin(), S[i].end());
if (S[i].size() >= sq) heavy_id.push_back(i);
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < heavy_id.size(); j++) {
int id = heavy_id[j];
if (i == id) continue;
int cnt = 0;
for (int k = 0; k < S[i].size(); k++) {
if (binary_search(S[id].begin(), S[id].end(), S[i][k])) {
cnt++;
}
}
link[i].push_back(make_pair(id, cnt));
}
}
while (q--) {
char ch;
scanf(" %c", &ch);
if (ch == '+') {
int k, x;
scanf("%d %d", &k, &x);
if (S[k].size() < sq) {
for (int i = 0; i < S[k].size(); i++) {
ara[S[k][i]] += x;
}
for (int i = 0; i < link[k].size(); i++) {
sum[link[k][i].first] += link[k][i].second * x;
}
} else {
up[k] += x;
}
} else {
int k;
scanf("%d", &k);
long long ans = 0;
if (S[k].size() < sq) {
for (int i = 0; i < S[k].size(); i++) {
ans += ara[S[k][i]];
}
for (int i = 0; i < link[k].size(); i++) {
ans += up[link[k][i].first] * link[k][i].second;
}
} else {
ans = sum[k] + up[k] * S[k].size();
for (int i = 0; i < link[k].size(); i++) {
ans += up[link[k][i].first] * link[k][i].second;
}
}
printf("%lld\n", ans);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, qt[303030], ord[303030];
char fora[303030];
vector<int> par[303030], tirou;
int main() {
srand(time(NULL));
scanf("%d%d", &n, &k);
int cnt = 0;
for (auto i = (1); i < (n + 1); i++)
for (int j = i + i; j <= n; j += i)
par[i].emplace_back(j), par[j].emplace_back(i), cnt++;
if (cnt < k) {
puts("No");
return 0;
}
iota(ord, ord + n, 0);
while (1) {
ans = n;
int aux = cnt;
for (auto i = (1); i < (n + 1); i++) qt[i] = ((int)(par[i]).size());
for (auto I = (0); I < (n); I++) {
int i = ord[I] + 1;
if (cnt - qt[i] >= k) {
cnt -= qt[i];
fora[i] = 1;
tirou.emplace_back(i);
for (auto j = (0); j < (((int)(par[i]).size())); j++)
if (!fora[par[i][j]]) qt[par[i][j]]--;
ans--;
}
}
if (cnt == k) break;
random_shuffle(ord, ord + n);
cnt = aux;
for (int v : tirou) fora[v] = 0;
tirou.clear();
}
puts("Yes");
printf("%d\n", ans);
for (auto i = (1); i < (n + 1); i++)
if (!fora[i]) printf("%d ", i);
printf("\n");
}
| 8 |
#include <bits/stdc++.h>
int dx[] = {0, 0, 1, -1, 2, 2, -2, -2, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, 1, -1, 1, -1, 2, 2, -2, -2};
using namespace std;
long long int mem[1010][1110];
long long int com(long long int n, long long int k) {
if (k > n) {
return 0;
}
if (k == n || k == 0) {
return 1;
}
if (mem[n][k] > 0) {
return mem[n][k];
}
return mem[n][k] =
((com(n - 1, k) % 1000000007) + com(n - 1, k - 1) % 1000000007) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int tcase = 1;
for (long long int test = 1; test <= tcase; test++) {
long long int num, m;
cin >> num >> m;
long long int ans = 0;
for (long long int i = 1; i <= num; i++) {
long long int ar_a_n = (i - 1) + 1;
long long int ar_b_n = (num - i) + 1;
long long int n_a = (ar_a_n - 1) + (m - 1);
long long int k_a = ar_a_n - 1;
long long int ans_a = com(n_a, k_a);
long long int n_b = (ar_b_n - 1) + m;
long long int k_b = ar_b_n - 1;
long long int ans_b = com(n_b, k_b);
long long int tm_ans =
((ans_b % 1000000007) * (ans_a % 1000000007)) % 1000000007;
ans = ((ans % 1000000007) + (tm_ans % 1000000007)) % 1000000007;
}
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int buang[2750140], id[2750140];
bool valid[2750140];
int main() {
long long int n, cnt = 0, a[400010], temp, prima[200010], b, c;
vector<long long int> ans;
memset(valid, true, sizeof valid);
valid[1] = false;
for (long long int i = 2; i < 2750132; i++)
if (valid[i]) {
prima[cnt] = i;
cnt++;
id[i] = cnt;
temp = i * i;
while (temp < 2750131) {
valid[temp] = false;
temp += i;
}
}
scanf("%lld", &n);
temp = n + n;
for (long long int i = 0; i < temp; i++) scanf("%lld", &a[i]);
sort(a, a + temp);
memset(buang, 0, sizeof buang);
for (long long int i = temp - 1; i >= 0; i--) {
b = a[i];
if (buang[b] > 0)
buang[b]--;
else if (valid[b]) {
c = id[b];
ans.push_back(c);
buang[c]++;
} else {
ans.push_back(b);
for (long long int j = 0; j < cnt; j++) {
c = prima[j];
if (b % c == 0) {
buang[b / c]++;
break;
}
}
}
}
for (long long int i = 0; i < n; i++) {
if (i > 0) putchar(' ');
printf("%lld", ans[i]);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, an;
int a[4][4];
bool f[50][50][50][4][4][4];
void dfs(int x, int y, int z, int A, int B, int C) {
int b[4] = {0, x, y, z}, c[4] = {0, A, B, C}, i, j, g[50] = {};
if (f[x][y][z][A][B][C]) return;
f[x][y][z][A][B][C] = 1;
for (i = 1; i <= 3; i++) g[b[i]] = i;
for (i = 1; i <= 3; i++) {
int t = b[i];
if (t <= 42) {
an = max(an, t);
if (!(c[i] & 1) && !g[42 + i]) {
for (j = t - a[i][2]; j <= t + a[i][2]; j++)
if (j > 0 && !g[j]) {
b[i] = j, c[i] ^= 1;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[i] = t;
c[i] ^= 1;
}
}
if (!(c[i] & 2) && !g[42 + i]) {
for (j = 1; j <= 3; j++) {
int v = b[j];
if (abs(t - v) != 1) continue;
b[j] = 42 + i;
c[i] ^= 2;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[j] = v;
c[i] ^= 2;
}
}
if (g[42 + i]) {
int A = g[42 + i];
for (j = t - a[i][3]; j <= t + a[i][3]; j++)
if (j > 0 && !g[j]) {
b[A] = j;
dfs(b[1], b[2], b[3], c[1], c[2], c[3]);
b[A] = 42 + i;
}
}
}
}
}
int main() {
for (i = 1; i <= 3; i++)
for (j = 1; j <= 3; j++) scanf("%d", &a[i][j]);
dfs(a[1][1], a[2][1], a[3][1], 0, 0, 0);
printf("%d\n", an);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
cin >> test;
for (int i = 0; i < test; i++) {
string s;
cin >> s;
int d = -1, f = -1, h = -1, a = -1, b = -1, c = -1;
int add2 = 2000000;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '1') {
d = i;
}
if (s[i] == '2') {
f = i;
}
if (s[i] == '3') {
h = i;
}
if (d != -1 && f != -1 && h != -1) {
int m1 = max(d, max(f, h));
int k1 = min(d, min(f, h));
int diff = m1 - k1;
if (diff < add2) add2 = diff;
}
}
if (d == -1 || h == -1 || f == -1)
cout << "0" << endl;
else {
cout << add2 + 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
using namespace std;
constexpr int mul(int a, int b) { return 1LL * a * b % MOD; }
template <typename... T>
constexpr int mul(int a, int b, T... t) {
return mul(mul(a, b), t...);
}
template <class T>
inline T Min(const T &a, const T &b) {
return a < b ? a : b;
}
template <class T>
inline T Max(const T &a, const T &b) {
return a < b ? b : a;
}
inline void inc(int &x, int &v, int &mod) {
x += v;
if (x >= mod) x -= mod;
}
inline void dec(int &x, int &v, int &mod) {
x -= v;
if (x < 0) x += mod;
}
inline int read() {
char ch = getchar();
int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long int readl() {
char ch = getchar();
long long int x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int T[200010 << 2][9], MIN[200010 << 2][9], minsum[200010 << 2][9];
int a[200010];
int res1, res2;
void pushup(int now, int k) {
T[now][k] = T[now << 1][k] + T[now << 1 | 1][k];
MIN[now][k] = Min(MIN[now << 1][k], MIN[now << 1 | 1][k]);
minsum[now][k] = Min(minsum[now << 1][k], minsum[now << 1 | 1][k]);
if (T[now << 1][k] != 0 && T[now << 1 | 1][k] != 0)
minsum[now][k] =
Min(minsum[now][k], MIN[now << 1][k] + MIN[now << 1 | 1][k]);
}
void build(int l, int r, int now, int k) {
if (l == r) {
int tmp = a[l];
for (int i = 0; i < k; i++) {
tmp /= 10;
}
minsum[now][k] = MIN[now][k] = 2e9;
if (tmp % 10 != 0) {
MIN[now][k] = a[l];
T[now][k] = 1;
} else
T[now][k] = 0;
return;
}
int mid = (l + r) >> 1;
build(l, mid, now << 1, k);
build(mid + 1, r, now << 1 | 1, k);
pushup(now, k);
}
int query(int L, int R, int l, int r, int now, int k) {
if (L <= l && r <= R) {
return T[now][k];
}
int mid = (l + r) >> 1;
int ans = 0;
if (L <= mid) ans += query(L, R, l, mid, now << 1, k);
if (mid < R) ans += query(L, R, mid + 1, r, now << 1 | 1, k);
return ans;
}
int query2(int L, int R, int l, int r, int now, int k) {
if (L <= l && r <= R) {
if (MIN[now][k] < res1) {
res2 = res1;
res1 = MIN[now][k];
} else if (MIN[now][k] < res2) {
res2 = MIN[now][k];
}
return minsum[now][k];
}
int mid = (l + r) >> 1;
int ans1 = 2e9, ans2 = 2e9;
if (L <= mid) ans1 = query2(L, R, l, mid, now << 1, k);
if (mid < R) ans2 = query2(L, R, mid + 1, r, now << 1 | 1, k);
return Min(ans1, ans2);
}
void update(int pos, int C, int l, int r, int now, int k) {
if (l == r) {
int tmp = C;
for (int i = 0; i < k; i++) tmp /= 10;
minsum[now][k] = MIN[now][k] = 2e9;
if (tmp % 10 != 0) {
MIN[now][k] = C;
T[now][k] = 1;
} else
T[now][k] = 0;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
update(pos, C, l, mid, now << 1, k);
else
update(pos, C, mid + 1, r, now << 1 | 1, k);
pushup(now, k);
}
int main() {
int n = read(), q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 0; i < 9; i++) {
build(1, n, 1, i);
}
while (q--) {
int op = read(), a = read(), b = read();
if (op == 1) {
for (int i = 0; i < 9; i++) update(a, b, 1, n, 1, i);
} else {
bool tag = true;
int sum = 2e9;
for (int i = 0; i < 9; i++) {
int cnt = query(a, b, 1, n, 1, i);
if (cnt > 1) {
res1 = res2 = 1e9;
sum = Min(Min((res1 + res2), sum), query2(a, b, 1, n, 1, i));
tag = false;
}
}
if (tag) {
printf("-1\n");
} else {
printf("%d\n", sum);
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int T, n, m, a[103][103], dx[4] = {0, 0, 1, 1}, dy[4] = {0, 1, 0, 1};
char c[103][103];
int main() {
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> c[i][j], a[i][j] = c[i][j] - '0';
vector<int> v[6];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == 1) {
for (int k = 1; k < 4; k++) {
int cnt = 0;
v[cnt++].push_back(i);
v[cnt++].push_back(j);
for (int l = 1; l < 4; l++)
if (k != l) {
v[cnt++].push_back(i + 1 < n ? i + dx[l] : i - dx[l]);
v[cnt++].push_back(j + 1 < m ? j + dy[l] : j - dy[l]);
}
}
}
cout << v[0].size() << '\n';
for (int i = 0; i < v[0].size(); i++)
cout << v[0][i] + 1 << ' ' << v[1][i] + 1 << ' ' << v[2][i] + 1 << ' '
<< v[3][i] + 1 << ' ' << v[4][i] + 1 << ' ' << v[5][i] + 1 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef struct point {
int x, y;
} myp;
typedef struct parent {
char x, y;
} parent;
int dis[9][9];
int vis[9][9];
int main() {
int yp[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
int xp[8] = {1, 1, 1, 0, -1, -1, -1, 0};
char s[8][2];
strcpy(s[0], "LU");
strcpy(s[1], "Uy");
strcpy(s[2], "RU");
strcpy(s[3], "Ry");
strcpy(s[4], "RD");
strcpy(s[5], "Dy");
strcpy(s[6], "LD");
strcpy(s[7], "Ly");
for (int i = 0; i <= 8; i++) {
for (int j = 0; j <= 8; j++) {
dis[i][j] = 100;
vis[i][j] = 0;
}
}
char c1, c2;
int r1, r2;
scanf("%c%d", &c1, &r1);
scanf("%c", &c2);
scanf("%c%d", &c2, &r2);
queue<myp> q;
myp a1, a2, val[9][9];
a1.x = r1;
a1.y = c1 - 96;
q.push(a1);
dis[a1.x][a1.y] = 0;
char parx[9][9], pary[9][9];
val[a1.x][a1.y].x = r1;
val[a1.x][a1.y].y = c1 - 96;
int k1 = 0;
while (!q.empty()) {
a1 = q.front();
q.pop();
vis[a1.x][a1.y] = 1;
for (int k1 = (int)0; k1 < (int)8; k1++) {
a2.x = a1.x + xp[k1];
a2.y = a1.y + yp[k1];
if (a2.x >= 1 && a2.x <= 8 && a2.y >= 1 && a2.y <= 8 &&
vis[a2.x][a2.y] == 0) {
if (dis[a2.x][a2.y] == 0 || dis[a2.x][a2.y] > dis[a1.x][a1.y] + 1) {
dis[a2.x][a2.y] = dis[a1.x][a1.y] + 1;
q.push(a2);
parx[a2.x][a2.y] = s[k1][0];
pary[a2.x][a2.y] = s[k1][1];
val[a2.x][a2.y] = a1;
}
}
}
}
printf("%d\n", dis[r2][c2 - 96]);
int i, x = r2;
int y = c2 - 96, k = 0;
char xstr[18];
char ystr[18];
while (!(x == val[x][y].x && y == val[x][y].y)) {
xstr[k] = parx[x][y];
ystr[k] = pary[x][y];
k++;
int t1 = val[x][y].x;
int t2 = val[x][y].y;
x = t1;
y = t2;
}
k--;
for (i = k; i >= 0; i--) {
printf("%c", xstr[i]);
if (ystr[i] != 'y') printf("%c", ystr[i]);
printf("\n");
;
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.