solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int maxn = 4e5 + 7;
bool dp[maxn];
int pre[maxn];
string s;
bool check(int to, int from) {
int cur = to;
while (cur < from && s[cur] != '.') cur++;
if (cur - to > 8 || cur - to == 0) return false;
if (from - cur == 0 || from - cur > 3) return false;
for (int i = cur + 1; i <= from; i++) {
if (s[i] == '.') return false;
}
return true;
}
int main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cin >> s;
int n = s.size();
memset(dp, 0, sizeof dp);
dp[0] = true;
for (int i = 1; i <= n; i++) {
for (int j = max(1, i - 11); j <= i - 2; j++) {
if (check(j - 1, i - 1) && dp[j - 1]) {
dp[i] = true;
pre[i] = j - 1;
break;
}
}
}
if (dp[n]) {
cout << "YES" << endl;
vector<string> res;
int cur = n;
while (cur > 0) {
res.push_back(string(s.begin() + pre[cur], s.begin() + cur));
cur = pre[cur];
}
reverse(res.begin(), res.end());
for (auto v : res) cout << v << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long sum = 0;
for (int i = 1; i < n; i++) {
sum += arr[i] - arr[i - 1] - 1;
}
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void GO_GO_GO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void BYE_BYE() {
cerr << "Time elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
}
bool primeArr[1000001] = {false};
long long int fact[1000001];
long long int lazy[1000001] = {0};
long long int BIT[1000001] = {0};
vector<long long int> primes;
int main() {
GO_GO_GO();
long long int t = 1;
cin >> t;
while (t--) {
long long int i = 0, j = 0;
long long int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<long long int> v(m);
for (i = 0; i < m; i++) {
cin >> v[i];
v[i]--;
}
vector<long long int> temp(n + 1, 0);
vector<long long int> ans(26, 0);
for (i = 0; i < m; i++) {
temp[v[i] + 1]--;
temp[0]++;
}
for (i = 1; i < n + 1; i++) {
temp[i] += temp[i - 1];
}
for (i = 0; i < n; i++) {
ans[s[i] - 'a'] += temp[i] + 1;
}
for (i = 0; i < 26; i++) cout << ans[i] << " ";
cout << "\n";
}
BYE_BYE();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b;
int main() {
ios_base::sync_with_stdio(false);
cout << "? ";
for (long long x = 1; x <= 100; ++x) cout << (x << 7) << " ";
cout << endl;
cin >> a;
a = a & ((1ll << 7) - 1);
cout << "? ";
for (long long x = 1; x <= 100; ++x) cout << x << " ";
cout << endl;
cin >> b;
b = (b >> 7);
cout << "! " << (a + (1ll << 7) * b) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for(int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for(int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int n;
string s;
vector<bool> sheep(100002), judge(100002);
bool solve(int x, int y) {
FOR(k, 2, n) sheep[k] = (sheep[k - 1] ^ (s[k - 1] == 'o')) ? sheep[k - 2] : 1 - sheep[k - 2];
if ((sheep[n-2] ^ (sheep[0]) ^ (sheep[n-1]) ^ (s[n-1] == 'x'))) return false;
if ((sheep[n-1] ^ sheep[1]) ^ (sheep[0] ^ (s[0] == 'x'))) return false;
return true;
}
int main() {
cin >> n >> s;
rep(i, n) judge[i] = s[i] == 'o';
s[n] = s[0];
rep(i, 2) rep(j, 2) {
sheep[0] = i;
sheep[1] = j;
if(solve(i, j)) {
rep(k, n) printf("%c", (sheep[k]) ? 'W' : 'S');
printf("\n");
return 0;
}
}
printf("-1\n");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int n;
struct REC {
int a, b, c, d;
} rec[N];
bool cmp1(REC& p, REC& q) { return p.a < q.a; }
bool cmp2(REC& p, REC& q) { return p.b < q.b; }
bool solve(int l, int r) {
if (l == r) return 1;
sort(rec + l, rec + r + 1, cmp1);
int xmax = 0;
for (int i = l; i <= r - 1; i++) {
xmax = max(xmax, rec[i].c);
if (rec[i + 1].a >= xmax) return solve(l, i) && solve(i + 1, r);
}
sort(rec + l, rec + r + 1, cmp2);
int ymax = 0;
for (int i = l; i <= r - 1; i++) {
ymax = max(ymax, rec[i].d);
if (rec[i + 1].b >= ymax) return solve(l, i) && solve(i + 1, r);
}
return 0;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++)
scanf("%d%d%d%d", &rec[i].a, &rec[i].b, &rec[i].c, &rec[i].d);
if (solve(1, n))
puts("YES");
else
printf("NO");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, x, y, z;
long long rem, ex;
bool flag = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> a >> b >> c;
cin >> x >> y >> z;
if (a > x) ex = (a - x) / 2;
if (b > y) ex += (b - y) / 2;
if (c > z) ex += (c - z) / 2;
if (a < x) {
rem = x - a;
if (ex < rem) flag = 0;
ex -= rem;
}
if (b < y) {
rem = y - b;
if (ex < rem) flag = 0;
ex -= rem;
}
if (c < z) {
rem = z - c;
if (ex < rem) flag = 0;
ex -= rem;
}
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int inf = 2e9;
using namespace std;
long long MOD = 1000000007;
typedef struct {
int a, b, c;
} iii;
void mosA(vector<int> a) {
for (int i = 0; i < a.size(); i++) printf("%d ", a[i]);
printf("\n");
}
void mosP(vector<pair<int, int> > a) {
for (int i = 0; i < a.size(); i++) printf("%d %d\n", a[i].first, a[i].second);
printf("\n");
}
bool ord(pair<int, int> a, pair<int, int> b) { return b.second < a.second; }
long long ans = 0;
int k, a, b, minimo, ver, t, p, n, m;
string S[300005];
string SOL[300005];
char** x;
pair<int, int> comp_col(int j, char* l) {
int ans1 = 0, ans2 = 0;
for (int i = 0; i < (n); i++)
if (S[i][j] == l[i % 2]) ans1++;
for (int i = 0; i < (n); i++)
if (S[i][j] == l[(i + 1) % 2]) ans2++;
if (ans1 > ans2) return {ans1, 1};
return {ans2, 2};
}
pair<int, int> comp_fil(int i, char* l) {
int ans1 = 0, ans2 = 0;
for (int j = 0; j < (m); j++)
if (S[i][j] == l[j % 2]) ans1++;
for (int j = 0; j < (m); j++)
if (S[i][j] == l[(j + 1) % 2]) ans2++;
if (ans1 > ans2) return {ans1, 1};
return {ans2, 2};
}
vector<int> comp_total_fil(char** p) {
int tot = 0;
vector<int> v;
v.push_back(1);
v.push_back(0);
for (int i = 0; i < (n); i++) {
pair<int, int> aux = comp_fil(i, p[i % 2]);
tot += aux.first;
v.push_back(aux.second);
}
v[1] = tot;
return v;
}
vector<int> comp_total_col(char** p) {
int tot = 0;
vector<int> v;
v.push_back(2);
v.push_back(0);
for (int i = 0; i < (m); i++) {
pair<int, int> aux = comp_col(i, p[i % 2]);
tot += aux.first;
v.push_back(aux.second);
}
v[1] = tot;
return v;
}
void crear(vector<int> v) {
int l = v.size();
vector<int> f;
for (int i = 2; i < l; i++) f.push_back(v[i]);
if (v[0] == 1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (f[i] == 1)
SOL[i] += x[i % 2][j % 2];
else
SOL[i] += x[i % 2][(j + 1) % 2];
}
if (v[0] == 2) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (f[j] == 1)
SOL[i] += x[j % 2][i % 2];
else
SOL[i] += x[j % 2][(i + 1) % 2];
}
}
int main() {
scanf("%d%d", &n, &m);
int maximo = 0;
vector<int> v1, v2, v;
for (int i = 0; i < (n); i++) cin >> S[i];
string c = "AGCT";
for (int i = 0; i < 24; i++) {
next_permutation(c.begin(), c.end());
char** p = (char**)malloc(sizeof(char*) * 2);
p[0] = (char*)malloc(sizeof(char) * 3);
p[1] = (char*)malloc(sizeof(char) * 3);
p[0][0] = c[0];
p[0][1] = c[1];
p[1][0] = c[2];
p[1][1] = c[3];
v1 = comp_total_fil(p);
v2 = comp_total_col(p);
if (v1[1] > maximo) {
maximo = v1[1];
v = v1;
x = p;
}
if (v2[1] > maximo) {
maximo = v2[1];
v = v2;
x = p;
}
}
crear(v);
for (int i = 0; i < (n); i++) cout << SOL[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(51);
const int K = 500;
int add[K][K];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, cnt = 0;
cin >> n >> m;
vector<int> x(n), y(n), ans(m), last(n), bal(m + 1);
vector<vector<int>> need(n);
set<int> st;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 0; i < m; i++) {
int op, k;
cin >> op >> k;
k--;
int a = x[k], b = y[k];
if (op == 1) {
cnt++;
if (a + b < K) {
last[k] = i;
for (int f = 0; f < a; f++) {
add[a + b][(f + i) % (a + b)]++;
}
} else {
need[k].push_back(i);
}
} else {
cnt--;
if (a + b < K) {
for (int f = 0; f < a; f++) {
add[a + b][(f + last[k]) % (a + b)]--;
}
} else {
need[k].push_back(i);
}
}
ans[i] = cnt;
for (int f = 1; f < K; f++) {
ans[i] -= add[f][i % f];
}
}
for (int i = 0; i < n; i++) {
if ((int)(need[i].size()) & 1) {
need[i].push_back(m);
}
for (int j = 0; j < need[i].size(); j += 2) {
int now = need[i][j];
while (now < need[i][j + 1]) {
if (now + x[i] - 1 < need[i][j + 1]) {
bal[now]++;
bal[now + x[i]]--;
} else {
bal[now]++;
bal[need[i][j + 1]]--;
}
now += x[i] + y[i];
}
}
}
int sum = 0;
for (int i = 0; i < m; i++) {
sum += bal[i];
ans[i] -= sum;
}
for (int i = 0; i < m; i++) {
cout << ans[i] << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
typedef long long ll;
const int n = 26;
ll s[365][26];
int main(){
ll d;
cin >> d;
vector<ll> c(n+1); //満足度低下
REP(i,n) cin >> c[i];
REP(i,d){
REP(j,n){
cin >> s[i][j];
}
}
vector<ll> schedule(d+1);
REP(i,d) {
cin >> schedule[i];
schedule[i];
}
vector<ll> score(d+1);
vector<ll> last(n+1,0);
ll score_d = 0;
//iは何日目
REP(i,d){
score_d += s[i][schedule[i]];
last[schedule[i]] = i;
REP(j,n){
score_d -= c[j]*(i - last[j]);
}
cout << score_d << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
void output(int a, int b, int c) {
if ((a + 3 * c) % 2 == 0) {
cout << 0 << endl;
} else
cout << 1 << endl;
}
void solve() {
int a, b, c;
cin >> a >> b >> c;
if (a >= 2 && b >= 1) {
output(a, b, c);
return;
}
if (a == 1 && b >= 3 && c >= 1) {
output(a, b, c);
return;
}
if (a == 0 && b >= 4 && c >= 2) {
output(a, b, c);
return;
}
if (b == 0 && a >= 3 && c >= 1) {
output(a, b, c);
return;
}
int minnum = 10;
for (int i = 0; i <= a; i++)
for (int j = 0; j <= b; j++)
for (int k = 0; k <= c; k++) {
int l = i + 2 * j + 3 * k, r = (a - i) + 2 * (b - j) + 3 * (c - k);
if (r - l < 0) break;
if (minnum > r - l) minnum = r - l;
if (minnum == 0) break;
}
cout << minnum << endl;
return;
}
int main() {
int _;
cin >> _;
while (_--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int k = 0;
for (int i = 0; i < n; i++)
if (a[i] > a[0] && a[i] < a[n - 1]) k++;
cout << k;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> nxt[1003];
vector<pair<int, int> > solve(int l, int r) {
if (l + 1 >= r) return vector<pair<int, int> >();
int t = *lower_bound(nxt[r].begin(), nxt[r].end(), l + 1);
vector<pair<int, int> > move;
move.push_back(pair<int, int>(l, r));
vector<pair<int, int> > tp = solve(l, t);
move.insert(move.end(), tp.begin(), tp.end());
tp = solve(t, r);
move.insert(move.end(), tp.begin(), tp.end());
return move;
}
vector<pair<int, int> > work() {
for (int i = 1; i <= N; ++i) nxt[i].clear();
for (int i = 1; i <= N; ++i) {
nxt[i].push_back(i % N + 1);
nxt[i].push_back(i == 1 ? N : i - 1);
}
for (int i = 1; i <= N - 3; ++i) {
int a, b;
cin >> a >> b;
nxt[a].push_back(b);
nxt[b].push_back(a);
}
for (int i = 1; i <= N; ++i) sort(nxt[i].begin(), nxt[i].end());
vector<pair<int, int> > ans;
for (int i = 1; i < nxt[1].size(); ++i) {
vector<pair<int, int> > tp = solve(nxt[1][i - 1], nxt[1][i]);
ans.insert(ans.end(), tp.begin(), tp.end());
}
return ans;
}
set<int> Edge[1003];
int main() {
cin >> N;
vector<pair<int, int> > frm = work(), to = work();
cout << frm.size() + to.size() << endl;
for (auto t : frm) cout << t.first << ' ' << t.second << endl;
reverse(to.begin(), to.end());
for (int i = 2; i <= N; ++i) {
Edge[i].insert(i - 1);
Edge[i].insert(i % N + 1);
Edge[1].insert(i);
}
for (auto t : to) {
int p = 0, q = 0;
for (int i = 1; i <= N && !q; ++i)
if (Edge[i].count(t.first) && Edge[i].count(t.second))
if (!p)
p = i;
else
q = i;
Edge[p].erase(q);
Edge[q].erase(p);
Edge[t.first].insert(t.second);
Edge[t.second].insert(t.first);
cout << p << ' ' << q << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
const long long inf = 2e9;
const int MAXN = 200000;
const int MAXM = 200000;
const int INF = 0x3f3f3f3f;
struct Edge {
int to, next, cap, flow, cost;
} edge[MAXM];
int head[MAXN], tol;
int pre[MAXN];
long long dis[MAXN];
bool vis[MAXN];
int N;
void init(int n) {
N = n;
tol = 0;
memset(head, -1, sizeof(head));
}
void addedge(int u, int v, int cap, int cost) {
edge[tol].to = v;
edge[tol].cap = cap;
edge[tol].cost = cost;
edge[tol].flow = 0;
edge[tol].next = head[u];
head[u] = tol++;
edge[tol].to = u;
edge[tol].cap = 0;
edge[tol].cost = -cost;
edge[tol].flow = 0;
edge[tol].next = head[v];
head[v] = tol++;
}
bool spfa(int s, int t) {
queue<int> q;
for (int i = 0; i < N; i++) {
dis[i] = INF;
vis[i] = false;
pre[i] = -1;
}
dis[s] = 0;
vis[s] = true;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = false;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
if (edge[i].cap > edge[i].flow && dis[v] > dis[u] + edge[i].cost) {
dis[v] = dis[u] + edge[i].cost;
pre[v] = i;
if (!vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
if (pre[t] == -1)
return false;
else
return true;
}
int minCostMaxflow(int s, int t, long long &cost) {
int flow = 0;
cost = 0;
while (spfa(s, t)) {
long long Min = INF;
for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
if (Min > edge[i].cap - edge[i].flow) Min = edge[i].cap - edge[i].flow;
}
for (int i = pre[t]; i != -1; i = pre[edge[i ^ 1].to]) {
edge[i].flow += Min;
edge[i ^ 1].flow -= Min;
cost += edge[i].cost * Min;
}
flow += Min;
}
return flow;
}
pair<int, vector<int>> a[maxn];
int main() {
ios::sync_with_stdio(false);
;
int n, p, k, x;
cin >> n >> p >> k;
for (int i = 0; i < n; i++) cin >> a[i].first;
for (int i = 0; i < n; i++)
for (int j = 0; j < p; j++) cin >> x, a[i].second.push_back(x);
sort(a, a + n, greater<pair<int, vector<int>>>());
int cnt = n;
int E = cnt++, S = cnt++;
int P[10];
for (int i = 0; i < p; i++) P[i] = cnt++;
int tmp = cnt++;
init(cnt);
set<int> e;
for (int i = 0; i < p; i++) {
addedge(S, P[i], 1, 0);
vector<pair<long long, long long>> v;
for (int j = 0; j < k; j++) v.push_back({-a[j].second[i] + a[j].first, j});
sort(v.begin(), v.end());
for (int j = 0; j < p && j < v.size(); j++)
addedge(P[i], v[j].second, 1, v[j].first),
addedge(v[j].second, tmp, 1, 0);
v.clear();
for (int j = k; j < n; j++) v.push_back({-a[j].second[i], j});
sort(v.begin(), v.end());
for (int j = 0; j < v.size() && j < 2 * p; j++)
addedge(P[i], v[j].second, 1, v[j].first), e.insert(v[j].second);
}
for (int j = k; j < k + p; j++) addedge(tmp, j, 1, -a[j].first);
for (int j = k; j < k + p; j++) e.insert(j);
for (int i : e) addedge(i, E, 1, 0);
long long ans;
minCostMaxflow(S, E, ans);
ans = -ans;
for (int i = 0; i < k; i++) ans += a[i].first;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int row, col, n, m, q, cnt, ara[100000 + 5], ans[100000 + 5];
unordered_map<int, int> mark;
void add(int pos) {
if (mark[ara[pos]] == ara[pos]) --cnt;
mark[ara[pos]]++;
if (mark[ara[pos]] == ara[pos]) {
cnt++;
}
}
void del(int pos) {
if (mark[ara[pos]] == ara[pos]) --cnt;
mark[ara[pos]] -= 1;
if (mark[ara[pos]] == ara[pos]) ++cnt;
}
int main() {
int T;
T = 1;
mark.reserve(1024);
mark.max_load_factor(0.25);
for (int tc = 1; tc <= T; tc++) {
vector<pair<pair<int, int>, pair<int, int> > > v;
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]);
int sq = sqrt(n);
for (int i = 1; i <= q; i++) {
int lft, rht;
scanf("%d %d", &lft, &rht);
v.push_back({{lft / sq, rht}, {lft, i}});
}
sort(v.begin(), v.end());
;
ara[0] = ara[1];
ara[n + 1] = ara[n];
int lft = 1, rht = 0;
for (pair<pair<int, int>, pair<int, int> > it : v) {
int queryLft = it.second.first, queryRht = it.first.second;
while (queryRht > rht) add(++rht);
while (queryRht < rht) del(rht--);
while (queryLft > lft) del(lft++);
while (queryLft < lft) add(--lft);
int idx = it.second.second;
ans[idx] = cnt;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
}
| 2 |
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#define MAXN 500010
#define LL long long
using namespace std;
const long double eps=1e-8;
int n;
LL V,px[MAXN];
long double py[MAXN];
pair<LL,long double> Q[MAXN];
int head=1,tail=1;
long double getK(pair<LL,long double> t1,pair<LL,long double> t2){
return (t2.second-t1.second)/(t2.first-t1.first);
}
void insert(LL x,long double y){
pair<LL,long double> pt(x,y);
while(tail-head>=1 && getK(pt,Q[tail])<getK(Q[tail],Q[tail-1])) Q[tail--];
Q[++tail]=pt;
}
void cut(LL x){
while(Q[head].first>x){
pair<LL,long double> temp=Q[head++];
if(Q[head].first<x){
long double ty=Q[head].second+getK(Q[head],temp)*(x-Q[head].first);
Q[--head]=make_pair(x,ty);
}
}
}
int main(){
#ifdef DEBUG
freopen("F.in","r",stdin);
#endif
scanf("%d%d",&n,&V);
for(int i=1;i<=n;i++){
double temp;
scanf("%lf%d",&temp,px+i);
py[i]=temp*px[i];
}
Q[1]=make_pair(0,0);
for(int i=1;i<=n;i++){
cut(Q[tail].first+V-px[i]);
insert(Q[tail].first-px[i],Q[tail].second-py[i]);
double ans=(Q[head].second-Q[tail].second)/V;
printf("%.7lf\n",ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e18;
int cnt[1000];
double EE = 0.001;
int main() {
int n, m;
float k;
cin >> n >> m >> k;
map<string, int> mapp;
for (int i = 1; i <= n; i++) {
string s;
int x;
cin >> s >> x;
int kk = int((k + EE) * 100);
int b = int(kk * x / 100);
if (b >= 100) mapp[s] = b;
}
for (int i = 1; i <= m; i++) {
string s;
cin >> s;
if (mapp[s] < 100) mapp[s] = 0;
}
cout << mapp.size() << endl;
map<string, int>::iterator it;
for (it = mapp.begin(); it != mapp.end(); it++) {
cout << (*it).first << " " << (*it).second << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Scanner {
bool hasNext = 1;
bool hasRead = 1;
int nextInt() {
hasRead = 0;
int res = 0;
char flag = 1, ch = getchar();
while (ch != EOF && !isdigit(ch)) {
hasRead = 1;
flag = (ch == '-') ? -flag : flag;
ch = getchar();
}
while (ch != EOF && isdigit(ch)) {
hasRead = 1;
res = res * 10 + (ch - '0');
ch = getchar();
}
if (ch == EOF) hasNext = 0;
return res * flag;
}
long long nextLL() {
hasRead = 0;
long long res = 0;
char flag = 1, ch = getchar();
while (ch != EOF && !isdigit(ch)) {
hasRead = 1;
flag = (ch == '-') ? -flag : flag;
ch = getchar();
}
while (ch != EOF && isdigit(ch)) {
hasRead = 1;
res = res * 10 + (ch - '0');
ch = getchar();
}
if (ch == EOF) hasNext = 0;
return res * flag;
}
char nextChar() {
hasRead = 0;
char ch = getchar();
while (ch != EOF && isspace(ch)) {
hasRead = 1;
ch = getchar();
}
if (ch == EOF) hasNext = 0;
return ch;
}
int nextString(char *str) {
hasRead = 0;
int len = 0;
char ch = getchar();
while (ch != EOF && isspace(ch)) {
hasRead = 1;
ch = getchar();
}
while (ch != EOF && !isspace(ch)) {
hasRead = 1;
str[++len] = ch;
ch = getchar();
}
str[len + 1] = 0;
if (ch == EOF) hasNext = 0;
return len;
}
} sc;
long long rd() {
long long x = sc.nextLL();
return x;
}
void rd(int &x) { x = sc.nextInt(); }
void rd(long long &x) { x = sc.nextLL(); }
void rd(char &x) { x = sc.nextChar(); }
void rd(char *x) { sc.nextString(x); }
template <typename T1, typename T2>
void rd(pair<T1, T2> &x) {
rd(x.first);
rd(x.second);
}
template <typename T>
void rd(T *x, int n) {
for (int i = 1; i <= n; ++i) rd(x[i]);
}
void printInt(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) printInt(x / 10);
putchar('0' + x % 10);
}
void printLL(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) printLL(x / 10);
putchar('0' + x % 10);
}
void pr(int x, char ch = '\n') {
printInt(x);
putchar(ch);
}
void pr(long long x, char ch = '\n') {
printLL(x);
putchar(ch);
}
template <typename T1, typename T2>
void pr(pair<T1, T2> x, char ch = '\n') {
pr(x.first, ' ');
pr(x.second, ch);
}
template <typename T>
void pr(T *x, int n) {
for (int i = 1; i <= n; ++i) pr(x[i], " \n"[i == n]);
}
template <typename T>
void pr(vector<T> &x) {
int n = x.size();
for (int i = 1; i <= n; ++i) pr(x[i - 1], " \n"[i == n]);
}
template <typename T>
void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void cmax(T &x, T y) {
if (y > x) x = y;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = acos(-1.0);
const double EPS = 1e-9;
const int MOD = 1000000007;
int n;
long long a[200005];
long long b[200005];
long long x[200005];
long long dp[200005];
int Q[200005];
double calc(int i2, int i1) {
return 1.0 * (dp[i2] - dp[i1]) / (x[i2] - x[i1]);
}
struct Solver {
void InitOnce() {}
void Read() {
rd(n);
rd(a, n);
rd(b, n);
}
void Solve() {
for (int i = 1; i <= n; ++i) x[i] = -b[i];
dp[1] = 0;
int l = 1, r = 0;
Q[++r] = 1;
for (int i = 2; i <= n; ++i) {
while (l < r && calc(Q[l + 1], Q[l]) <= 1.0 * a[i]) ++l;
dp[i] = dp[Q[l]] + a[i] * b[Q[l]];
while (l < r && calc(Q[r], Q[r - 1]) >= calc(i, Q[r])) --r;
Q[++r] = i;
}
printf("%lld\n", dp[n]);
}
} solver;
int main() {
solver.InitOnce();
int t = 1;
t = INF;
while (t--) {
solver.Read();
if (!sc.hasRead) break;
solver.Solve();
if (!sc.hasNext) break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long> > matmul(vector<vector<long long> > &a,
vector<vector<long long> > &b) {
int i, j, k, n = a.size();
vector<vector<long long> > ans(n, vector<long long>(n));
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
long long temp = 0;
for (k = 0; k < n; k++)
temp = (temp + a[i][k] * b[k][j]) % (1000000007LL);
ans[i][j] = temp;
}
return ans;
}
vector<vector<long long> > matpwr(vector<vector<long long> > &a, long long p) {
int n = a.size();
vector<vector<long long> > ans(n, vector<long long>(n));
for (int i = 0; i < n; i++) ans[i][i] = 1;
while (p) {
if (p & 1) ans = matmul(ans, a);
a = matmul(a, a);
p >>= 1;
}
return ans;
}
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long invMod(long long n, long long mod = (1000000007LL)) {
return pwr(n, mod - 2);
}
int main() {
ios_base::sync_with_stdio(0);
double s, a, b, c;
cin >> s >> a >> b >> c;
if (a == 0 && b == 0 && c == 0) {
cout << fixed << setprecision(16) << "0.0 0.0 0.0";
return 0;
}
double x, y, z;
x = a * s / (a + b + c);
y = b * s / (a + b + c);
z = c * s / (a + b + c);
cout << fixed << setprecision(16) << x << " " << y << " " << z;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
stringstream ss;
long long mod = 1000000007LL;
int t[100010];
int in[100010];
vector<int> adj[100010];
int main() {
int n, x;
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
in[x]++;
if (x) adj[i].push_back(x);
}
int mx = 0;
vector<int> v;
for (int i = 1; i <= n; i++)
if (t[i]) {
stack<int> st;
st.push(i);
int now = i;
while (adj[now].size()) {
now = adj[now][0];
if (in[now] != 1) break;
st.push(now);
}
if (st.size() > mx) {
mx = st.size();
v.clear();
while (st.size()) v.push_back(st.top()), st.pop();
}
}
cout << mx << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 500 + 10;
const long long mod = 998244353;
const int inf = 0x3ffffff;
const double eps = 1e-5;
int n, m;
int h[11];
int cntc[maxn], cntf[maxn];
int dp[5010][510];
map<int, int> mp;
int check(int x, int y) {
for (int i = 0; i <= x; i++)
for (int j = 0; j <= y; j++) dp[i][j] = 0;
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= y; j++) {
for (int k = 1; k <= min(m, i); k++) {
dp[i][j] = max(dp[i][j], dp[i - k][j - 1] + h[k]);
}
}
}
return dp[x][y];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n * m; i++) {
int a;
cin >> a;
cntc[a]++;
}
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
cntf[a]++;
}
for (int i = 1; i <= m; i++) cin >> h[i];
int ans = 0;
for (int i = 1; i <= 1e5; i++)
if (cntc[i] != 0 && cntf[i] != 0) {
ans += check(cntc[i], cntf[i]);
}
cout << ans;
return ~~(0 - 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos((long double)-1);
namespace fft {
template <class T>
class comp {
public:
T real, img;
comp(T a = (T)0, T b = (T)0) : real(a), img(b) {}
comp conj() { return comp(this->real, -(this->img)); }
comp operator=(const comp& a) {
this->real = a.real, this->img = a.img;
return *this;
}
comp operator+(const comp& b) {
return comp(this->real + b.real, this->img + b.img);
}
comp operator-(const comp& b) {
return comp(this->real - b.real, this->img - b.img);
}
comp operator*(const T& num) {
return comp(this->real * num, this->img * num);
}
comp operator/(const T& num) {
return comp(this->real / num, this->img / num);
}
comp operator*(const comp& b) {
return comp(this->real * b.real - this->img * b.img,
this->img * b.real + this->real * b.img);
}
comp operator/(const comp& b) {
comp temp(b.real, -b.img);
comp n = (*this) * temp;
return n / (b.x * b.x + b.y * b.y);
}
};
comp<long double> w[1 << 20];
int rev[1 << 20];
void revbits(int newlim) {
static int lim = -1;
int t, j;
if (newlim == lim) return;
lim = newlim;
int k = 0;
while ((1 << k) < newlim) ++k;
assert((1 << k) == newlim);
for (int i = 1; i <= (int)(lim); ++i) {
j = rev[i - 1];
t = k - 1;
while (t >= 0 && ((j >> t) & 1)) j ^= (1 << t), --t;
if (t >= 0) j ^= (1 << t), --t;
rev[i] = j;
}
}
void fft(vector<comp<long double> >& poly, int inv = false) {
int len, l;
revbits((int)(poly).size());
for (int i = 0; i < (int)((int)(poly).size()); ++i)
if (rev[i] > i) swap(poly[i], poly[rev[i]]);
comp<long double> u, v;
for (len = 2, l = 1; len <= (int)(poly).size(); len += len, l += l) {
if (w[l].real == 0 && w[l].img == 0) {
long double ang = PI / l;
comp<long double> ww(cos(ang), sin(ang));
if (l > 1) {
for (int j = 0; j < l; ++j) {
if (j & 1)
w[l + j] = w[(l + j) >> 1] * ww;
else
w[l + j] = w[(l + j) >> 1];
}
} else
w[l] = comp<long double>(1.0, 0.0);
}
for (int i = 0; i < (int)(poly).size(); i += len)
for (int j = 0; j < (int)(l); ++j) {
u = poly[i + j],
v = poly[i + j + l] * (inv ? w[l + j].conj() : w[l + j]);
poly[i + j] = u + v, poly[i + j + l] = u - v;
}
}
if (inv)
for (auto& x : poly) x = x / (long double)(int)(poly).size();
}
void fft2d(vector<vector<comp<long double> > >& A, bool inv = false) {
for (auto& row : A) {
fft(row, inv);
}
vector<comp<long double> > col((int)(A).size());
for (int j = 0; j < (int)((int)(A.front()).size()); ++j) {
for (int i = 0; i < (int)((int)(A).size()); ++i) col[i] = A[i][j];
fft(col, inv);
for (int i = 0; i < (int)((int)(A).size()); ++i) A[i][j] = col[i];
}
}
vector<vector<comp<long double> > > multiply(
vector<vector<comp<long double> > >& x,
vector<vector<comp<long double> > >& y) {
int b_rows = 0, b_cols = 0;
while ((1 << b_rows) <= max((int)(x).size(), (int)(y).size())) ++b_rows;
++b_rows;
while ((1 << b_cols) <= max((int)(x.front()).size(), (int)(y.front()).size()))
++b_cols;
++b_cols;
x.resize(1 << b_rows);
y.resize(1 << b_rows);
for (auto& row : x) row.resize(1 << b_cols, 0);
for (auto& row : y) row.resize(1 << b_cols, 0);
fft2d(x), fft2d(y);
for (int i = 0; i < (int)((int)(x).size()); ++i)
for (int j = 0; j < (int)((int)(x[i]).size()); ++j)
x[i][j] = x[i][j] * y[i][j];
fft2d(x, 1);
return x;
}
const int L = 805;
string A[L], B[L];
int N, M, R, C, X, Y;
void read() {
cin >> N >> M;
for (int i = 0; i < (int)(N); ++i) cin >> A[i];
cin >> R >> C;
for (int i = 0; i < (int)(R); ++i) cin >> B[i];
}
void solve() {
X = N + R, Y = M + C;
vector<vector<comp<long double> > > a(X, vector<comp<long double> >(Y));
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(M); ++j) {
a[i][j].real = cos(2 * PI * (A[i][j] - 'a') / 26.0),
a[i][j].img = sin(2 * PI * (A[i][j] - 'a') / 26.0);
for (int ii = i; ii < X; ii += N)
for (int jj = j; jj < Y; jj += M) a[ii][jj] = a[i][j];
}
vector<vector<comp<long double> > > b(R, vector<comp<long double> >(C));
int valid = 0;
for (int i = 0; i < (int)(R); ++i)
for (int j = 0; j < (int)(C); ++j) {
if (B[i][j] == '?') continue;
++valid;
b[R - i - 1][C - j - 1].real = cos(2 * PI * (B[i][j] - 'a') / 26.0),
b[R - i - 1][C - j - 1].img =
-sin(2 * PI * (B[i][j] - 'a') / 26.0);
}
vector<vector<comp<long double> > > c = multiply(a, b);
for (int i = 0; i < (int)(N); ++i) {
for (int j = 0; j < (int)(M); ++j)
cout << ((int)(c[R - 1 + i][C - 1 + j].real + 1e-5) == valid);
cout << "\n";
}
}
} // namespace fft
int main() {
std::ios::sync_with_stdio(false);
fft::read();
fft::solve();
return 0;
}
| 5 |
//ICPC2012C 偏りのあるサイコロ
#include<iostream>
#include<algorithm>
#define FIELD 9
using namespace std;
enum {S,E,N,W};
int top[FIELD][FIELD];//上面の目
int z[FIELD][FIELD];//高さ
int side[3+1][4]={
{},
{3,5,4,2},
{3,1,4,6},
{1,2,6,5},
};
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
void print(int t,int f,int i){
cout<<t<<' '<<f<<' '<<i<<endl;
for(int i=0;i<FIELD;i++){
cout<<" ";
for(int j=0;j<FIELD;j++){
cout<<top[i][j];
}
cout<<endl;
}
}
int getIndex(int t,int n){
if(3<t)t = 7-t;
for(int i=0;i<4;i++)
if(side[t][i]==n)return i;
return -1;
}
void roll(int *t,int *f,int n,int compass){
if(compass==N){
*f = 7-*t;
}
else if(compass==S){
*f = *t;
}
*t = 7-n;
}
void fall(int y,int x,int t,int f){
for(int i=6;4<=i;i--){
int index=getIndex(t,i);
if(index==-1)
continue;
index = (index-getIndex(t,f)+4) %4;
if(3<t)index = (4-index)%4;
if(z[y+dy[index]][x+dx[index]] >= z[y][x])
continue;
roll(&t,&f,i,index);
fall(y+dy[index],x+dx[index],t,f);
return;
}
z[y][x]++;
top[y][x] = t;
}
int main(){
int n;
int num[6+1];
while(cin>>n,n){
fill_n(num,7,0);
fill_n((int*)z,FIELD*FIELD,0);
fill_n((int*)top,FIELD*FIELD,0);
for(int i=0;i<n;i++){
int t,f;
cin>>t>>f;
fall(FIELD/2,FIELD/2,t,f);
}
for(int i=0;i<FIELD;i++)
for(int j=0;j<FIELD;j++)
num[top[i][j]]++;
cout<<num[1];
for(int i=2;i<=6;i++)cout<<' '<<num[i];
cout<<endl;
}
return 0;
} | 0 |
#include"bits/stdc++.h"
using namespace std;
int main() {
int X, Y;
cin >> X >> Y;
if (X == 1 && Y == 1) {
cout << 1000000 << endl;
}
else {
cout << (max(4 - X, 0) + max(4 - Y, 0)) * 100000 << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long msb(long long val) { return 63 - __builtin_clzll(val); }
inline int msb(int val) { return 31 - __builtin_clz(val); }
template <class T>
bool chmin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
const long long mod = 1e9 + 7, N = 2e5 + 5;
long long a[N], n, m, k;
long long pr[17] = {2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47, 53, 59};
long long fact[62];
long long dp[101][1 << 17], t[101][1 << 17];
void solve(long long test_case) {
long long i, j;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
for (i = 1; i <= 60; i++) {
for (j = 0; j < 17; j++) {
if (i % pr[j] == 0) fact[i] |= (1 << j);
}
}
memset(dp, 0x3f, sizeof dp);
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (k = 1; k < 60; k++) {
long long x = (~fact[k]) & ((1 << 17) - 1);
for (j = x;; j = (j - 1) & x) {
if (chmin(dp[i][j | fact[k]], dp[i - 1][j] + abs(a[i] - k)))
t[i][j | fact[k]] = k;
if (j == 0) break;
}
}
}
long long p = -1, res = mod;
for (i = 0; i < (1 << 17); i++) {
if (chmin(res, dp[n][i])) p = i;
}
vector<long long> ans;
for (i = n; i >= 1; i--) {
ans.push_back(t[i][p]);
p ^= fact[t[i][p]];
}
reverse((ans).begin(), (ans).end());
for (auto x : ans) cout << x << ' ';
cout << '\n';
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve(1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T> bool chmax(T& a, const T& b){ if(a < b){ a = b; return 1; } return 0; }
int main(){
ll n, t;
cin >> n >> t;
vector<vector<ll>> dp(t, vector<ll>(2));
for(ll i = 0; i < n; i++){
ll a, b;
cin >> a >> b;
for(ll i = t; i --> a; ) chmax(dp[i][1], dp[i - a][1] + b);
for(ll i = 0; i < t; i++) chmax(dp[i][1], dp[i][0] + b);
for(ll i = t; i --> a; ) chmax(dp[i][0], dp[i - a][0] + b);
}
cout << max(dp[t - 1][0], dp[t - 1][1]) << endl;
}
| 0 |
#include<map>
#include<stack>
#include<queue>
#include<string>
#include<math.h>
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int P=139;
const int mod=149;
const int maxn=1e6+5;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int minn=0xc0c0c0c0;
int n,ans,res,sit,a[maxn],b[maxn];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=n;i>=1;i--)
cin>>b[i];
for(int i=1;i<=n;i++)
{
if(a[i]==b[i])
{
bool flag=0;
for(int j=1;j<=n;j++)
{
if(a[i]!=b[j]&&a[j]!=b[i])
{
swap(b[i],b[j]);
flag=1;
break;
}
}
if(!flag)
{
cout<<"No"<<endl;
return 0;
}
}
}
cout<<"Yes"<<endl;
for(int i=1;i<=n;i++)
cout<<b[i]<<" ";
cout<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[10110];
int main() {
int t;
cin >> t;
while (t) {
int n, mi = 1000000;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 1; i < n; i++) {
if (mi > (arr[i] - arr[i - 1])) {
mi = arr[i] - arr[i - 1];
}
}
cout << mi << "\n";
t--;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const long double pi = acos((ld)-1.0);
const double eps = (double)1e-9;
const int inf = 1e9 + 7;
const int N = 505;
int n;
string s;
int dp[N][N];
int calc(int l, int r) {
int &res = dp[l][r];
if (res != -1) return res;
if (l > r) return res = 0;
if (l == r) return res = 1;
res = 1 + calc(l + 1, r);
for (int i = l + 1; i <= r; i++) {
if (s[i] == s[l]) {
res = min(res, calc(l + 1, i - 1) + calc(i, r));
}
}
return res;
}
int main() {
cin >> n >> s;
memset(dp, -1, sizeof dp);
cout << calc(0, n - 1);
return 0;
}
const int fastio = []() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
return 0;
}();
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[50005], b[50005];
string s[50005];
int main() {
int t, n, m, i, j;
char x;
cin >> t;
while (t--) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
cin >> n >> m;
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (s[i][j] == '.') a[i]++;
for (j = 0; j < m; j++)
for (i = 0; i < n; i++)
if (s[i][j] == '.') b[j]++;
int minx = 10000000, sum = 0, ans;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i] + b[j] - (s[i][j] == '.') < minx)
minx = a[i] + b[j] - (s[i][j] == '.');
}
}
printf("%d\n", minx);
}
return 0;
}
| 2 |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
double v;
while(cin >> v) {
double y = v*v / 19.6;
double N = (y+5.0) / 5.0;
cout << ceil(N) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
using namespace std;
int main() {
int t = 0;
cin >> t;
bool *ans = new bool[t]{};
for (int i = 0; i < t; i++) {
int a, b;
cin >> a >> b;
if (gcd(a, b) == 1) {
ans[i] = true;
} else {
ans[i] = false;
}
}
for (int i = 0; i < t; i++) {
if (i != 0) cout << endl;
if (ans[i]) {
cout << "Finite";
} else {
cout << "Infinite";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
v[i] = (v[i] % k == 0 ? 0 : k - v[i] % k);
}
map<int, long long> remc;
for (int i : v) {
remc[i] = 0;
}
for (int i : v) {
if (i == 0) {
continue;
}
if (remc[i] == 0) {
remc[i] = i;
} else {
remc[i] += k;
}
}
long long ma = 0;
for (pair<int, long long> p : remc) {
ma = max(ma, p.second);
}
if (ma == 0) {
cout << 0 << "\n";
} else {
cout << ma + 1 << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void print_digit(int a);
void print_dahai(int a);
int main() {
int d;
scanf("%d", &d);
if (d < 10) {
print_digit(d);
return 0;
}
if (9 < d && d < 20) {
switch (d) {
case 10:
printf("ten");
break;
case 11:
printf("eleven");
break;
case 12:
printf("twelve");
break;
case 13:
printf("thirteen");
break;
case 14:
printf("fourteen");
break;
case 15:
printf("fifteen");
break;
case 16:
printf("sixteen");
break;
case 17:
printf("seventeen");
break;
case 18:
printf("eighteen");
break;
case 19:
printf("nineteen");
break;
}
return 0;
} else {
int a = floor(d / 10);
print_dahai(a);
int b = d % 10;
if (b != 0) {
printf("-");
print_digit(b);
}
}
return 0;
}
void print_digit(int a) {
switch (a) {
case 0:
printf("zero");
break;
case 1:
printf("one");
break;
case 2:
printf("two");
break;
case 3:
printf("three");
break;
case 4:
printf("four");
break;
case 5:
printf("five");
break;
case 6:
printf("six");
break;
case 7:
printf("seven");
break;
case 8:
printf("eight");
break;
case 9:
printf("nine");
break;
}
return;
}
void print_dahai(int a) {
switch (a) {
case 0:
break;
case 2:
printf("twenty");
break;
case 3:
printf("thirty");
break;
case 4:
printf("forty");
break;
case 5:
printf("fifty");
break;
case 6:
printf("sixty");
break;
case 7:
printf("seventy");
break;
case 8:
printf("eighty");
break;
case 9:
printf("ninety");
break;
}
return;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int walk[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
struct ARROW {
int x0, y0, x1, y1;
ARROW *to[55];
long long dis[55];
int dir() { return x0 < x1 ? 0 : y0 < y1 ? 1 : x0 > x1 ? 2 : 3; }
};
inline bool xl(ARROW *a, ARROW *b) {
return max(a->x0, a->x1) < max(b->x0, b->x1);
}
inline bool xg(ARROW *a, ARROW *b) {
return min(a->x0, a->x1) > min(b->x0, b->x1);
}
inline bool yl(ARROW *a, ARROW *b) {
return max(a->y0, a->y1) < max(b->y0, b->y1);
}
inline bool yg(ARROW *a, ARROW *b) {
return min(a->y0, a->y1) > min(b->y0, b->y1);
}
int N, B, Q;
long long T[maxn];
ARROW A[maxn], *S[maxn];
void Init(bool (*cmp)(ARROW *, ARROW *), int dir, int ARROW::*y0,
int ARROW::*y1) {
for (int i = 1; i <= N + Q; i++) S[i] = A + N + Q - i + 1;
stable_sort(S + 1, S + N + Q + 1, cmp);
multimap<int, ARROW *> F;
typedef multimap<int, ARROW *>::iterator it;
for (int i = 1; i <= N + Q; i++) {
if (S[i] - A <= N) {
it lo = F.lower_bound(min(S[i]->*y0, S[i]->*y1));
it hi = F.upper_bound(max(S[i]->*y0, S[i]->*y1));
for (it j = lo; j != hi; j++) {
j->second->to[0] = S[i];
j->second->dis[0] =
abs(j->second->x1 - S[i]->x1) + abs(j->second->y1 - S[i]->y1);
}
F.erase(lo, hi);
}
if (S[i]->dir() == dir) F.insert(make_pair(S[i]->*y0, S[i]));
}
}
int main() {
scanf("%d%d", &N, &B);
for (int i = 1; i <= N; i++)
scanf("%d%d%d%d", &A[i].x0, &A[i].y0, &A[i].x1, &A[i].y1);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
char dir;
scanf("%d%d %c%I64d", &A[i + N].x0, &A[i + N].y0, &dir, &T[i]);
A[i + N].x1 = A[i + N].x0, A[i + N].y1 = A[i + N].y0;
switch (dir) {
case 'R':
A[i + N].x0--;
break;
case 'L':
A[i + N].x0++;
break;
case 'U':
A[i + N].y0--;
break;
case 'D':
A[i + N].y0++;
}
}
Init(xl, 0, &ARROW::y0, &ARROW::y1);
Init(xg, 2, &ARROW::y0, &ARROW::y1);
Init(yl, 1, &ARROW::x0, &ARROW::x1);
Init(yg, 3, &ARROW::x0, &ARROW::x1);
for (int k = 1; k < 50; k++)
for (ARROW *i = A + 1; i <= A + N + Q; i++)
if (i->to[k - 1] && i->to[k - 1]->to[k - 1]) {
i->to[k] = i->to[k - 1]->to[k - 1];
i->dis[k] = i->dis[k - 1] + i->to[k - 1]->dis[k - 1];
}
for (int i = 1; i <= Q; i++) {
ARROW *now = A + i + N;
long long t = T[i];
for (int k = (t ? 63 - __builtin_clzll(t) : -1); k >= 0; k--)
if (now->to[k] && now->dis[k] <= t) t -= now->dis[k], now = now->to[k];
int x = now->x1, y = now->y1, dir = now->dir();
if (now->to[0]) {
int half;
if (now->x0 == now->x1) {
half = max(0, min((now->to[0]->y0 - now->y1) / walk[dir][1],
(now->to[0]->y1 - now->y1) / walk[dir][1]));
if (half <= t)
t -= half, y += walk[dir][1] * half, dir = now->to[0]->dir();
} else {
half = max(0, min((now->to[0]->x0 - now->x1) / walk[dir][0],
(now->to[0]->x1 - now->x1) / walk[dir][0]));
if (half <= t)
t -= half, x += walk[dir][0] * half, dir = now->to[0]->dir();
}
}
x = min<long long>(B, max(0ll, x + walk[dir][0] * t));
y = min<long long>(B, max(0ll, y + walk[dir][1] * t));
printf("%d %d\n", x, y);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int q, n, br[456789], ar[456789], d, k, sum, l, r, a[3], b, i;
string s, t;
bool ok[123];
void dii() {
cin >> n >> d >> k;
for (int i = 0; i < d; i++) {
cin >> b;
if (!ok[b]) {
br[b] = 1;
ok[b] = 1;
}
}
for (int i = 0; i < k; i++) {
cin >> b;
if (!ok[b]) {
br[b] = 2;
ok[b] = 1;
}
}
for (int i = 1; i <= n; i++) {
cout << br[i] << ' ';
}
}
int main() {
faster();
q = 1;
while (q--) {
dii();
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
long long ans = (-1)*1E10;
int main(){
int n;
cin >> n;
int f[n][10],p[n][10];
for(int i=0;i<n;i++){
for(int j=0;j<10;j++){
cin >> f[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0;j<11;j++){
cin >> p[i][j];
}
}
for(int i=1;i<(1<<10);i++){
bitset<10> s(i);
int cnt=0;
for(int j=0;j<n;j++){
int cnt1=0;
for(int k=0;k<10;k++){
if(s.test(k)==1&&f[j][k]==1) cnt1++;
}
cnt+=p[j][cnt1];
}
if(ans<cnt) ans = cnt;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q, x, y, c;
struct data {
int id, typ, x, y;
data() { id = typ = x = y = -1; }
data(int _id, int _typ, int _x, int _y) {
id = _id;
typ = _typ;
x = _x;
y = _y;
}
};
vector<data> v;
int par[100005], canPar[100005];
vector<pair<int, int> > qq[100005];
bool res[100005];
int getPar(int x) {
if (x != par[x]) par[x] = getPar(par[x]);
return par[x];
}
vector<int> e[100005];
int st[100005], nd[100005];
bool done[100005];
int d;
void dfs(int u, int p) {
d++;
done[u] = 1;
st[u] = d;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i];
if (v == p) continue;
dfs(v, u);
}
nd[u] = d;
return;
}
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n >> q;
int pos = 0;
for (int i = 1; i <= q; i++) {
cin >> c;
if (c == 1) {
cin >> x >> y;
e[y].push_back(x);
canPar[x] = 1;
} else if (c == 2) {
cin >> x;
} else {
cin >> x >> y;
qq[y].push_back(pair<int, int>(pos, x));
pos++;
continue;
}
v.push_back(data(i, c, x, y));
}
for (int i = 1; i <= n; i++) {
par[i] = i;
if (done[i]) continue;
if (canPar[i]) continue;
dfs(i, i);
}
int cnt = 1;
for (int i = 0; i < v.size(); i++) {
data now = v[i];
if (now.typ == 1) {
int u = getPar(now.y);
int v = getPar(now.x);
par[v] = par[u];
} else {
int u = now.x;
int p1 = getPar(u);
for (int j = 0; j < qq[cnt].size(); j++) {
pair<int, int> nw = qq[cnt][j];
int p = nw.second;
int p2 = getPar(p);
if (p1 == p2 && st[p] <= st[u] && st[u] <= nd[p]) {
res[nw.first] = 1;
}
}
cnt++;
}
}
for (int i = 0; i < pos; i++) {
if (res[i])
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 5 |
#include "bits/stdc++.h"
#define REP(i,n) for(ll i=0;i<ll(n);++i)
#define RREP(i,n) for(ll i=ll(n)-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<ll(n);++i)
#define RFOR(i,m,n) for(ll i=ll(n)-1;i>=ll(m);--i)
#define ALL(v) (v).begin(),(v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
constexpr int dx[8] = { 1,1,0,-1,-1,-1,0,1 };
constexpr int dy[8] = { 0,1,1,1,0,-1,-1,-1 };
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } return false; }
template <class T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } return false; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, d;
while (cin >> n >> d, n) {
vvi v(n);
int cnt = 0;
REP(i, n) {
int k; cin >> k;
v[i].resize(k);
cnt += k;
REP(j, k)cin >> v[i][j];
}
vi sum(n);
REP(i, n)REP(j, v[i].size())sum[i] += v[i][j];
auto f = [&](int a, int b) {
return sum[a] < sum[b];
};
priority_queue<int, vi, decltype(f)> q(f), tmp(f);
REP(i, n)q.push(i);
while (cnt) {
int a = -INF;
bool updated = false;
while (!q.empty()) {
int p = q.top(); q.pop();
if (v[p].empty())continue;
int t;
if (a == -INF)t = sum[q.top()];
else t = a;
if (sum[p] - v[p].back() >= t - d) {
sum[p] -= v[p].back();
v[p].pop_back();
q.push(p);
cnt--;
updated = true;
}
else {
tmp.push(p);
if (a == -INF)a = sum[p];
}
}
while (!tmp.empty()) {
q.push(tmp.top());
tmp.pop();
}
if (!updated)break;
}
if (cnt == 0)cout << "Yes" << endl;
else cout << "No" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10, mod = 1e7 + 7, inf = 0x3f3f3f3f;
int n, m, k, t;
void up(long long &x, long long y) {
if (x < y) x = y;
}
void ex_gcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return;
}
ex_gcd(b, a % b, x, y);
long long tmp = x;
x = y;
y = tmp - a / b * y;
}
int main() {
int i, j;
long long n, k, l, r;
cin >> n >> l >> r >> k;
long long x = r - l + 1;
if (x <= 0) x += n;
long long y = n - x;
long long ret = -1;
if (1. * n * n < 1. * k / n) {
for (long long a = 0; a <= x; a++)
for (long long b = 0; b <= y; b++) {
if ((k - x - a) >= 0 && (k - x - a) % (y + b + x + a) == 0)
up(ret, a + b);
if (!a) continue;
++k;
if ((k - x - a) >= 0 && (k - x - a) % (y + b + x + a) == 0)
up(ret, a + b);
--k;
}
} else {
for (long long c = k - x, t = 0; c >= 0; c -= n, t++) {
long long p = c, q = -c;
if (!t) {
if (c <= x) up(ret, c + y);
continue;
}
long long z = min((y - q) / (t + 1), p / t);
if (p - z * t >= 0 && p - z * t <= x && q + z * (t + 1) >= 0 &&
q + z * (t + 1) <= y)
up(ret, p + q + z);
}
++k;
for (long long c = k - x, t = 0; c >= 0; c -= n, t++) {
long long p = c, q = -c;
if (!t) {
if (c <= x) up(ret, c + y);
continue;
}
long long z = min((y - q) / (t + 1), (p - 1) / t);
if (p - z * t >= 0 && p - z * t <= x && q + z * (t + 1) >= 0 &&
q + z * (t + 1) <= y)
up(ret, p + q + z);
}
}
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5100, mod = 1e9 + 7;
int n, m;
char s[MAXN], t[MAXN];
int dp[MAXN][27], sum[MAXN];
int C[MAXN][MAXN];
int gmod(int x) { return ((x % mod + mod)) % mod; }
int g(int x, int y) { return C[x + 1][y + 1]; }
void init() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (s[i] != s[i - 1]) t[++m] = s[i] - 'a' + 1;
}
C[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
void solve() {
dp[0][0] = 1;
sum[0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = i; j >= 1; j--) {
int x = t[i], ans = gmod(sum[j - 1] - dp[j - 1][x]);
sum[j] = gmod(sum[j] + ans - dp[j][x]);
dp[j][x] = ans;
}
}
int ans = 0;
for (int j = 1; j <= m; j++) {
int tmp = 0;
for (int c = 1; c <= 26; c++) tmp = (tmp + dp[j][c]) % mod;
ans = (ans + 1LL * g(n - 1, j - 1) * tmp) % mod;
}
printf("%d\n", ans);
}
int main() {
init();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define repp(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)
typedef long long LL;
typedef long double LD;
vector<vector<int>> v;
int sol(vector<int> &s){
int x = 0;
rep(i,4){
x=v[x][s[i]];
}
return x;
}
bool isValid(vector<int> &s){
int x = 0;
rep(i,5){
x = v[x][s[i]];
}
if(x) return false;
else return true;
}
int main(){
int n = 10;
v=vector<vector<int>>(n,vector<int>(n));
rep(i,n) rep(j,n) cin >> v[i][j];
int ans=0;
rep(i,10000){
int x = i;
vector<int> s(5);
per(j,4){
s[j]=x%10;
x/=10;
}
s[4]=sol(s);
bool ok = true;
vector<int> tmp;
rep(j,5){
rep(k,10){
if(k==s[j]) continue;
tmp=s;
tmp[j]=k;
if(isValid(tmp)) ok=false;
}
}
rep(j,4){
if(s[j]==s[j+1]) continue;
tmp=s;
swap(tmp[j],tmp[j+1]);
if(isValid(tmp)) ok=false;
}
if(!ok) ans++;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <set>
#include <vector>
#include <functional>
using namespace std;
typedef pair<int, int> P;
void solve()
{
vector<P> Vec;
set<int, greater<int> > Set;
P p;
while(~scanf("%d,%d", &p.first, &p.second))
{
if(!p.first && !p.second)
{
break;
}
Vec.push_back(p);
Set.insert(p.second);
}
int n;
while(cin >> n)
{
int count = 0;
for(set<int, greater<int> >::iterator Ite = Set.begin(); Ite != Set.end(); ++Ite)
{
++count;
if(*Ite == Vec[n - 1].second)
{
break;
}
}
cout << count << endl;
}
}
int main()
{
solve();
return(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long INFll = 1ll * 1000000000 * 1000000000;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int mul(int a, int b, int mod = 998244353) { return int(a * 1ll * b % mod); }
int norm(int a, int mod = 998244353) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
int powmod(int x, int y, int mod = 998244353) {
int res = 1;
while (y > 0) {
if (y & 1) res = mul(res, x, mod);
x = mul(x, x, mod);
y = y >> 1;
}
return res;
}
int inv(int a, int mod = 998244353) { return powmod(a, mod - 2); }
vector<int> v[200005], dp(200005, 0);
void dfs(int u, int p) {
dp[u] = 1;
int k = 2;
if (u == 1) k--;
for (auto e : v[u]) {
if (e != p) {
dfs(e, u);
dp[u] = ((dp[u] * 1ll * dp[e]) % 998244353 * 1ll * k) % 998244353;
k++;
}
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 1);
cout << (n * 1ll * dp[1]) % 998244353 << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int PRIME = 999983;
const int MOD = 10007;
const int MULTI = 1000000007;
const double EPS = 1e-9;
int x[256], sum[128], blg[128];
int main() {
int n, cnt = 0, m = 0;
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) scanf("%d", &x[i]), sum[x[i]]++;
for (int i = 10; i <= 99; i++)
if (sum[i] == 1) cnt++;
m = cnt /= 2;
for (int i = 10; i <= 99; i++)
if (sum[i] == 1 && cnt) blg[i]++, cnt--, sum[i]--;
for (int i = 10; i <= 99; i++)
if (sum[i] >= 2)
blg[i] += sum[i] / 2, m += sum[i] / 2, sum[i] -= sum[i] / 2;
if (m < n) {
m = n - m;
for (int i = 10; m && i <= 99; i++)
if (sum[i] > 1) {
int t = min(m, sum[i] - 1);
m -= t, blg[i] += t, sum[1] -= t;
}
}
int a = 0, b = 0;
for (int i = 10; i <= 99; i++)
if (sum[i]) a++;
for (int i = 10; i <= 99; i++)
if (blg[i]) b++;
printf("%d\n", a * b);
for (int i = 0; i < 2 * n; i++)
if (blg[x[i]])
printf("1 "), blg[x[i]]--;
else
printf("2 ");
puts("");
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int d1, d2, d3, a, b, c, s;
scanf("%d %d %d", &d1, &d2, &d3);
s = d1 + d2 + d3;
a = 2 * (d1 + d2);
b = 2 * (d1 + d3);
c = 2 * (d2 + d3);
if (a < b && a < c && a < s) printf("%d", a);
if (b < a && b < c && b < s) printf("%d", b);
if (c < a && c < b && c < s) printf("%d", c);
if (s < a && s < b && s < c)
printf("%d", s);
else if (s == a || s == b || s == c)
printf("%d", s);
}
| 1 |
#include <bits/stdc++.h>
#define N 200010
using namespace std;
int cnt[N], n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int k; scanf("%d", &k);
cnt[k]++;
}
sort(cnt + 1, cnt + 1 + n);
int Ans = n;
for (int i = n; i > n - k; i--) Ans -= cnt[i];
cout << Ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main ()
{
int count;
cin >> count;
for (int x = 1; x <= count; x++) {
long long n;
cin >> n;
stringstream ss;
ss << n;
cout << "Case " << x << ":" << endl;
for (int i = 0; i < 10; i++) {
n *= n;
n /= 100;
int j = 0;
int k = 1;
int tmp = 0;
while (j < 4) {
tmp += (n % 10) * k;
k *= 10;
n /= 10;
j++;
}
n = tmp;
cout << tmp << endl;
}
}
return 0;
} | 0 |
#include <stdio.h>
int d, s, t;
int main() {
scanf("%d%d%d", &d, &s, &t);
if (s * t < d)printf("No\n");
else printf("Yes\n");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
char s[5];
long long get(char ch) {
if (ch >= 'd' && ch <= 'f') return 'f' - ch + 1;
if (ch <= 'c' && ch >= 'a') return ch - 'a' + 4;
}
int main() {
cin >> n;
scanf("%s", s);
if ((n - 1) % 4 == 0 || (n - 1) % 4 == 1) {
ans = (n - 1) / 4 * 12 + (n - 1) % 2 * 6 + get(s[0]) + n - 1;
} else {
ans = (n - 1) / 4 * 12 + (n - 1) % 2 * 6 + get(s[0]) + n - 3;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n,k,now=1,a[223456][60];
int d(long long now,int k){
if(!a[now][k])a[now][k]=d(d(now,k-1),k-1);
return a[now][k];
}
int main(){
cin>>n>>k;
for(int i=1;i<=n;i++)cin>>a[i][0];
for(int i=0;i<60;i++)if((k>>i)&1)now=d(now,i);
cout<<now<<endl;
}
| 0 |
/*
Author : Arvinder Singh
*/
#include <bits/stdc++.h>
using namespace std;
#define FIO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
void INPUT()
{
#ifndef ONLINE_JUDGE
freopen("C:/Users/arvindersingh/Desktop/Current/input.txt", "r", stdin);
freopen("C:/Users/arvindersingh/Desktop/Current/output.txt", "w", stdout);
#endif
}
#define ll long long
#define ar array
//#define PI 3.14159
const double PI=acos(-1);
const long long mod = 1e9+7;
#define vint vector<int>
#define vfloat vector<float>
#define pb push_back
#define fo(i,n) for(i=0;i<n;i++)
#define fok(i,k,n) for(i=k;i<n;i++)
int size=1000000;
//int a[size];
int k,n,m;
void solve() {
cin>>k>>n>>m;
vector<int> a(n),b(m);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
for (int i = 0; i < m; ++i)
{
cin>>b[i];
}
/////////// logic
int itr1=0,itr2=0;
vector<int> ans;
while(itr1<n or itr2<m){
if(itr1 < n and a[itr1] == 0){
ans.push_back(a[itr1]);
k++;
itr1++;
}
else if(itr1 < n and a[itr1] <= k){
ans.push_back(a[itr1]);
itr1++;
}else if(itr2 < m and b[itr2] == 0){
ans.push_back(b[itr2]);
k++;
itr2++;
}else if(itr2 < m and b[itr2] <= k){
ans.push_back(b[itr2]);
itr2++;
}else{
cout<<"-1"<<endl;
return;
}
}
for(int i:ans)
cout<<i<<" ";
cout<<endl;
}
int main(int argc, char const *argv[])
{
FIO
INPUT();
ll t = 1;
cin >> t;
while (t--)
{
solve();
}
return 0;
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
bitset <333> a[333];
int n, m;
const int mod = 998244353;
long long pw[333];
int main(int argc, char const *argv[])
{
scanf("%d %d", &n, &m);
pw[0] = 1;
for(int i = 1; i <= max(n, m); i++) {
pw[i] = pw[i - 1] * 2;
pw[i] %= mod;
}
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
int x;
scanf("%d", &x);
a[i][j] = x;
}
}
int ptr = 0;
for(int j = 0; j < m; j++) {
for(int i = ptr; i < n; i++) {
if(a[i][j] == 1) {
swap(a[ptr], a[i]);
for(int x = 0; x < n; x++) {
if(x != ptr && a[x][j] == 1) {
a[x] ^= a[ptr];
}
}
++ptr;
break;
}
}
}
long long res = pw[m-1] * (pw[n] - pw[n - ptr]);
res %= mod;
if(res < 0) res += mod;
printf("%lld\n", res);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long count = 0, total_count = 0;
cin >> n;
vector<int> front;
vector<int> back;
for (int i = 0; i < n; i++) {
int l, f = 0;
cin >> l;
int ysb[l + 1];
for (int i = 0; i < l; i++) {
cin >> ysb[i];
}
for (int i = 0; i < l; i++) {
if (i != 0 && ysb[i] > ysb[i - 1]) {
count++;
f++;
break;
}
}
if (!f) {
front.push_back(ysb[0]);
back.push_back(ysb[l - 1]);
}
}
sort(front.begin(), front.end());
sort(back.begin(), back.end());
for (auto itr = front.begin(); itr != front.end(); itr++) {
total_count += back.end() - lower_bound(back.begin(), back.end(), *itr);
}
cout << n * n - total_count;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a, b, num[100][100], heng[100][100], lie[100][100], i, j, n, m;
int qiu(int a, int b) {
int s, x, l, r, y, ans, i, j, k;
if (a > n || b > m) return (10000000);
ans = 10000000;
k = 0;
for (i = 1; i <= a; i++) k = k + heng[i][b];
for (i = 0; i <= m - b; i++) {
l = 1 + i;
r = b + i;
ans = min(ans, k);
y = k;
for (j = 1; j <= n - a; j++) {
s = j + 1;
x = a + j;
k = k - (heng[s - 1][r] - heng[s - 1][l - 1]) +
(heng[x][r] - heng[x][l - 1]);
ans = min(k, ans);
}
k = y - lie[l][a] + lie[r + 1][a];
}
return (ans);
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &num[i][j]);
heng[i][j] = heng[i][j - 1] + num[i][j];
}
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++) lie[i][j] = lie[i][j - 1] + num[j][i];
scanf("%d%d", &a, &b);
printf("%d\n", min(qiu(a, b), qiu(b, a)));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int memo[200001];
int a[200001];
int b[200001][3];
int solve(int i) {
if (i == n) {
return memo[i] = 0;
}
int &ret = memo[i];
if (ret != -1) return ret;
int x1 = 1e9, x2 = 1e9, x3 = 1e9;
x1 = 20 + solve(b[i][0]);
x2 = 50 + solve(b[i][1]);
x3 = 120 + solve(b[i][2]);
return ret = min(x1, min(x2, x3));
}
int main() {
memset(memo, -1, sizeof(memo));
cin >> n;
for (int i = n - 1; i >= 0; i--) {
cin >> a[i];
a[i] = -a[i];
}
for (int i = 0; i < n; i++) {
int itr = upper_bound(a, a + n, a[i]) - a;
b[i][0] = itr;
itr = upper_bound(a, a + n, a[i] + 89) - a;
b[i][1] = itr;
itr = upper_bound(a, a + n, a[i] + 1439) - a;
b[i][2] = itr;
}
solve(0);
int last = 0;
for (int i = n - 1; i >= 0; i--) {
printf("%d\n", max(memo[i] - last, 0));
last = max(last, memo[i]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
struct BIT {
private:
vector<int> t;
public:
BIT(int n) { t.assign(n + 1, 0); }
void update(int p, int x) {
for (int i = p; i < t.size(); i += i & (-i)) t[i] += x;
}
int query(int p) {
int res = 0;
for (int i = p; i > 0; i -= i & (-i)) res += t[i];
return res;
}
};
struct query {
int l, r, id;
};
bool cmpQ(const query &a, const query &b) { return a.l > b.l; }
int n, m, pos[200005], ans[200005];
vector<pair<int, int> > s;
vector<query> Q;
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) {
int x;
scanf("%d", &x);
pos[x] = i;
}
for (int i = (1); i <= (n); ++i) {
for (int j = i; j <= n; j += i) {
int l = pos[i], r = pos[j];
if (l > r) swap(l, r);
s.push_back(make_pair(l, r));
}
}
sort(s.begin(), s.end());
for (int i = (1); i <= (m); ++i) {
int l, r;
scanf("%d%d", &l, &r);
Q.push_back({l, r, i});
}
sort(Q.begin(), Q.end(), cmpQ);
int i = (int)s.size() - 1;
BIT t(n);
for (query q : Q) {
while (i >= 0 && s[i].first >= q.l) {
t.update(s[i].second, 1);
--i;
}
ans[q.id] = t.query(q.r);
}
for (int i = (1); i <= (m); ++i) printf("%d\n", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[5010];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
int ans = 22;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (x >= a[i] * j) {
int t = x - a[i] * j;
if (!t) {
ans = min(ans, j);
break;
}
for (int k = j + 1; k <= m; k++)
if (t % (k - j) == 0) {
int y = t / (k - j);
int lo = 0, hi = n + 1;
while (hi - lo > 1) {
int mi = (lo + hi) / 2;
if (a[mi] < y)
lo = mi;
else
hi = mi;
}
if (a[hi] == y) {
ans = min(ans, k);
break;
}
}
}
if (ans == 22) ans = -1;
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100 * 1000 + 10;
int a[MAX], b[MAX];
int main() {
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
for (int i = (int)0; i < (int)n; ++i) cin >> a[i];
for (int i = (int)0; i < (int)m; ++i) cin >> b[i];
if (n > m) {
cout << "YES" << endl;
return 0;
}
sort(a, a + n);
sort(b, b + m);
for (int i = (int)n - 1; i > (int)-1; --i)
if (a[i] > b[m - n + i]) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, H;
int main(int argc, char *argv[]) {
scanf("%d%d", &N, &H);
for (int i = 1; i < N; ++i) {
printf("%.12lf ", sqrt(double(i) / double(N)) * (double)H);
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, t, x, mx;
char a[2000005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> s >> t;
int len = s.size();
int poz = -len;
for (int j = 1; j <= t; j++) {
cin >> x;
for (int l = max(0, poz + len - x); l < len; l++) a[x + l] = s[l];
poz = x;
mx = max(mx, x + len);
}
}
for (int i = mx - 1; i > 0; i--)
if (!a[i]) a[i] = 'a';
cout << a + 1;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long a,b,n;
cin>>a>>b>>n;
long long x=min(n,b-1);
cout<<a*x/b;
return 0;
} | 0 |
#include<iostream>
#include<iomanip>
#include<vector>
#include<string>
#define rep(i, start, end) for (int i = (int)start; i < (int)end; ++i)
#define rrep(i, start, end) for (int i = (int)start - 1; i >= end; --i)
#define iter(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define riter(i, c) for (auto i = (c).rbegin(); i != (c).rend(); ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
const ll INF = 1LL << 50;
double f(const vector<double>& x, const vector<double>& y, const vector<char>& d, double t) {
double max_x = -INF;
double min_x = INF;
double max_y = -INF;
double min_y = INF;
rep(i, 0, x.size()) {
double now_x = x[i];
double now_y = y[i];
if (d[i] == 'U') now_y += t;
else if (d[i] == 'D') now_y -= t;
else if (d[i] == 'L') now_x -= t;
else now_x += t;
max_x = max(max_x, now_x);
min_x = min(min_x, now_x);
max_y = max(max_y, now_y);
min_y = min(min_y, now_y);
}
return (max_x - min_x) * (max_y - min_y);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<double> X(N), Y(N);
vector<char> D(N);
rep(i, 0, N) cin >> X[i] >> Y[i] >> D[i];
double l = 0.0, r = 1e10;
rep(i, 0, 500) {
double t1 = (2 * l + r) / 3;
double t2 = (l + 2 * r) / 3;
if (f(X, Y, D, t1) < f(X, Y, D, t2)) {
r = t2;
}
else l = t1;
}
cout << fixed << setprecision(10) << f(X, Y, D, l) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, arr[100009], kkiri[100009], kknan[100009], idxmin[100009], temp,
valmin, imin;
scanf("%d", &N);
temp = 0;
kkiri[0] = 0;
for (int i = 1; i <= N; i++) {
scanf("%d", &arr[i]);
temp += arr[i];
kkiri[i] = temp;
}
kkiri[N + 1] = temp;
kknan[0] = temp;
for (int i = 1; i <= N; i++) {
kknan[i] = temp - kkiri[i - 1];
}
kknan[N + 1] = 0;
imin = N + 1;
valmin = 0;
idxmin[N + 1] = imin;
for (int i = N; i >= 1; --i) {
if (kknan[i] < valmin) {
valmin = kknan[i];
imin = i;
}
idxmin[i] = imin;
}
idxmin[0] = imin;
for (int i = 0; i <= N; ++i) {
temp = kkiri[idxmin[i + 1] - 1] - 2 * kkiri[i] - kknan[idxmin[i + 1]];
if ((temp > valmin) || (i == 0)) valmin = temp;
}
printf("%d\n", valmin);
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
int l, r;
while (cin >> l >> r){
int ans = 0;
for (int i = l; i <= r; i++){
int q = i;
while (q % 2 == 0)q /= 2;
while (q % 3 == 0)q /= 3;
while (q % 5 == 0)q /= 5;
if (q == 1)ans++;
}
cout << ans << endl;
}
} | 0 |
#include <iostream>
using namespace std;
int main()
{
int a,b,x;
cin>>a>>b>>x;
if (a<=x and a+b>x) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
int main()
{
int w,n,a,b; cin >> w >> n;
int* num = new int[w+1];
for(int i=0; i<w+1; i++){ num[i]=i;}
for(int i=0; i<n; i++){
scanf("%d,%d", &a, &b);
swap(num[a],num[b]);
}
for(int i=1; i<w+1; i++){ cout << num[i] << endl;}
delete[] num;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long nax = 2e6 + 10;
vector<vector<int> > v;
vector<long long> dep;
void dfs(long long s, long long p) {
for (int i = 0; i < v[s].size(); ++i) {
if (v[s][i] == p) continue;
dep[v[s][i]] = 1 + dep[s];
dfs(v[s][i], s);
}
}
void solve() {
long long n, x, y, m;
cin >> n >> m;
v.resize(n + 1);
dep.resize(n + 1, -1);
for (int i = 0; i < m; ++i) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long ans = 0;
dep[1] = 0;
dfs(1, 1);
long long ind = 0;
for (int i = 1; i <= n; ++i) {
if (ans < dep[i]) {
ans = dep[i];
ind = i;
}
dep[i] = -1;
}
dep[0] = 0;
dep[ind] = 0;
dfs(ind, ind);
cout << *max_element(dep.begin(), dep.end()) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1, t1 = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int MAXN = 1e7;
const int MAXLOGN = 30;
long long qp(long long a, long long b, long long mod) {
if (b == 0) return 1 % mod;
long long hold = qp(a % mod, b / 2, mod) % mod;
return (((hold * hold) % mod) * (b & 1 ? a % mod : 1)) % mod;
}
int p, k;
int v[1000005];
int c;
int main() {
scanf("%d%d", &p, &k);
for (int i = 1; i < p; ++i) {
if (v[i]) continue;
long long s = i;
while (!v[s]) v[s] = 1, s = (s * k) % p;
c++;
}
printf("%lld\n", qp(p, c + (k == 1 ? 1 : 0), 1e9 + 7));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cntO, fa[300005], sz[300005], st[300005], ans[300005];
struct Edge {
int u, v, w, id;
} e[300005], e1[300005];
bool cmp(Edge x, Edge y) { return x.w == y.w ? x.id < y.id : x.w < y.w; }
void clear() {
cntO = n;
for (int i = 1; i <= n; ++i) fa[i] = i, sz[i] = 1;
}
int findRt(int x) { return x == fa[x] ? x : findRt(fa[x]); }
void merge(Edge z) {
int x = findRt(z.u), y = findRt(z.v);
if (x == y) return;
if (sz[x] & 1 && sz[y] & 1) cntO -= 2;
if (sz[x] < sz[y])
fa[x] = y, sz[y] += sz[x], st[++st[0]] = x;
else
fa[y] = x, sz[x] += sz[y], st[++st[0]] = y;
}
void rev(int lim) {
while (st[0] > lim) {
int x = st[st[0]--], y = fa[x];
fa[x] = x;
sz[y] -= sz[x];
if (sz[x] & 1 && sz[y] & 1) cntO += 2;
}
}
void slv(int l, int r, int wL, int wR) {
if (l > r) return;
int mid = (l + r) / 2, tmp1 = st[0], tmp2 = 0;
for (int i = l; i <= mid; ++i)
if (e1[i].w < wL) merge(e1[i]);
tmp2 = st[0];
for (int i = wL; i <= wR; ++i)
if (e[i].id <= mid) {
merge(e[i]);
if (!cntO) {
ans[mid] = i;
break;
}
}
rev(tmp2);
if (!ans[mid]) {
slv(mid + 1, r, wL, wR);
rev(tmp1);
return;
}
slv(mid + 1, r, wL, ans[mid]);
rev(tmp1);
for (int i = wL; i < ans[mid]; ++i)
if (e[i].id < l) merge(e[i]);
slv(l, mid - 1, ans[mid], wR);
rev(tmp1);
}
int main() {
scanf("%d %d", &n, &m);
clear();
for (int i = 1, u, v, w; i <= m; ++i)
scanf("%d %d %d", &u, &v, &w), e[i] = (Edge){u, v, w, i}, e1[i] = e[i];
sort(e + 1, e + m + 1, cmp);
for (int i = 1; i <= m; ++i) e1[e[i].id].w = i;
slv(1, m, 1, m);
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i] ? e[ans[i]].w : -1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long T;
long long a, b, c, d, zz;
int main() {
cin >> T;
while (T--) {
cin >> a >> b >> c >> d;
if (a > b * c) {
cout << -1 << endl;
continue;
}
if (c <= d - 1) {
cout << a << endl;
continue;
}
if (c > d - 1) {
zz = a / (d * b);
cout << (zz + 1) * a - (zz + 1) * zz / 2 * d * b << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long int;
const int kModulo = 998244353;
int idiv(int value) {
int u = value;
int v = kModulo;
int p1 = 1, q1 = 0;
int p2 = 0, q2 = 1;
while (v != 0) {
int q = u / v;
int p3 = p1 - q * p2;
int q3 = q1 - q * q2;
int r = u - q * v;
u = v;
v = r;
p1 = p2;
p2 = p3;
q1 = q2;
q2 = q3;
}
if (p1 < 0) {
p1 += kModulo;
}
if (p1 >= kModulo) {
p1 -= kModulo;
}
return p1;
}
vector<complex<double>> BW(int k) {
vector<complex<double>> p(1 << k, 1);
for (int u = 1; u < k; ++u) {
complex<double> current =
polar<double>(1.0, 3.14159265358979323846264338327950288 / (1 << u));
for (int v = (1 << (u - 1)); v < (1 << u); ++v) {
p[2 * v] = p[v];
p[2 * v + 1] = p[v] * current;
}
}
return p;
}
void MakeIt(int k, vector<complex<double>>& w, bool dir,
vector<complex<double>>* x) {
int n = 1 << k;
vector<complex<double>>& t = *x;
if (t.size() < static_cast<size_t>(n)) {
t.insert(t.end(), n - t.size(), 0.0);
}
int q = 0;
for (int i = 1; i < n; ++i) {
for (int j = 0;; ++j) {
q ^= (1 << (k - j - 1));
if ((i & (1 << j)) != 0) {
break;
}
}
if (q < i) {
swap(t[i], t[q]);
}
}
for (int l = 0; l < k; ++l) {
int o = 1 << l;
for (int i = 0; i < n; i += 2 * o) {
for (int u = i, v = i + o, q = o; u < i + o; ++u, ++v, ++q) {
auto v1 = (t[v].real() + t[v].imag()) * (w[q].real() + w[q].imag());
auto v2 = t[v].real() * w[q].real();
auto v3 = t[v].imag() * w[q].imag();
complex<double> tmp(v2 - v3, v1 - v2 - v3);
t[v] = t[u] - tmp;
t[u] += tmp;
}
}
}
if (dir) {
double n_inv = 1.0 / n;
t[0] *= n_inv;
t[n / 2] *= n_inv;
for (int i = 1; i < n / 2; ++i) {
swap(t[i], t[n - i]);
t[i] *= n_inv;
t[n - i] *= n_inv;
}
}
}
class Tree {
public:
explicit Tree(int n) : edges_(n) {}
void AddEdge(int u, int v) {
edges_[u].push_back(v);
edges_[v].push_back(u);
}
int Calc(int64 x) {
size_.assign(edges_.size(), 0);
dfs(0, -1);
Compute(0);
vector<int> p = Combine();
int64 current = 1;
int answer = 0;
const int xMod = x % kModulo;
for (size_t i = 1; i < p.size(); ++i) {
answer = (answer + p[i] * current) % kModulo;
current = (current * (xMod + i)) % kModulo;
current = (current * idiv(i)) % kModulo;
}
return answer;
}
private:
void dfs(int node, int parent) {
size_[node] = 1;
for (size_t i = 0; i < edges_[node].size(); ++i) {
int child = edges_[node][i];
if (child != parent) {
dfs(child, node);
size_[node] += size_[child];
} else {
swap(edges_[node][i--], edges_[node].back());
edges_[node].resize(edges_[node].size() - 1);
}
}
}
void Compute(int node) {
if (edges_[node].empty()) {
state_.push_back({0, 1});
return;
}
if (edges_[node].size() == 1) {
Compute(edges_[node][0]);
state_.push_back({0, 1});
} else {
int left = edges_[node][0];
int right = edges_[node][1];
if (size_[left] < size_[right]) {
swap(left, right);
}
Compute(right);
vector<int> right_result = Combine();
Compute(left);
state_.push_back(move(right_result));
ao(&state_.back());
mull(&state_.back());
}
}
vector<int> Combine() {
vector<int> result = Combine(0, state_.size()).second;
state_.clear();
return result;
}
pair<vector<int>, vector<int>> Combine(size_t start, size_t limit) {
if (start + 1 == limit) {
return {state_[start], state_[start]};
}
size_t middle = (start + limit) / 2;
auto left = Combine(start, middle);
auto right = Combine(middle, limit);
return {proiz(left.first, right.first),
PolyAdd(proiz(left.second, right.first), right.second)};
}
static void mull(vector<int>* p) {
vector<int>& t = *p;
t.push_back(0);
for (size_t i = t.size() - 1; i >= 1; --i) {
t[i] = t[i - 1];
}
t[0] = 0;
}
static void ao(vector<int>* p) {
int& p0 = p->at(0);
++p0;
if (p0 == kModulo) {
p0 = 0;
}
}
static vector<int> PolyAdd(const vector<int>& a, const vector<int>& b) {
vector<int> c(max(a.size(), b.size()));
for (size_t i = 0; i < c.size(); ++i) {
c[i] = (i < a.size() ? a[i] : 0);
if (i < b.size()) {
c[i] += b[i];
if (c[i] >= kModulo) {
c[i] -= kModulo;
}
}
}
return c;
}
static vector<int> proiz(const vector<int>& f, const vector<int>& g) {
size_t k = 0;
while ((static_cast<size_t>(1) << k) < f.size() + g.size() - 1) {
++k;
}
int n = 1 << k;
auto w = BW(k);
int z = static_cast<int>(floor(sqrt(kModulo)));
vector<complex<double>> ab(n);
vector<complex<double>> cd(n);
for (size_t i = 0; i < ab.size(); ++i) {
ab[i] = (i < f.size() ? complex<double>(f[i] / z, f[i] % z) : 0.0);
cd[i] = (i < g.size() ? complex<double>(g[i] / z, g[i] % z) : 0.0);
}
MakeIt(k, w, false, &ab);
MakeIt(k, w, false, &cd);
vector<complex<double>>& ac_bd = ab;
vector<complex<double>>& ad_bc = cd;
{
complex<double> ac_bd0 = complex<double>(ab[0].real() * cd[0].real(),
ab[0].imag() * cd[0].imag());
complex<double> ad_bc0 = complex<double>(ab[0].real() * cd[0].imag(),
ab[0].imag() * cd[0].real());
ac_bd[0] = ac_bd0;
ad_bc[0] = ad_bc0;
}
for (int i = 1; i <= n / 2; ++i) {
auto a = (ab[i] + conj(ab[n - i])) / 2.0;
auto ib = (ab[i] - conj(ab[n - i])) / 2.0;
auto c = (cd[i] + conj(cd[n - i])) / 2.0;
auto d = (cd[i] - conj(cd[n - i])) * complex<double>(0.0, -1.0 / 2.0);
auto ac = a * c;
auto ad = a * d;
auto ibc = ib * c;
auto ibd = ib * d;
ac_bd[i] = ac + ibd;
ad_bc[i] = ad + ibc;
ac_bd[n - i] = conj(ac - ibd);
ad_bc[n - i] = conj(ad - ibc);
}
MakeIt(k, w, true, &ac_bd);
MakeIt(k, w, true, &ad_bc);
vector<int> result(f.size() + g.size() - 1);
int64 z2 = static_cast<int64>(z) * z;
for (size_t i = 0; i < result.size(); ++i) {
int64 v0 = static_cast<int64>(round(ac_bd[i].imag())) % kModulo;
int64 v1 = static_cast<int64>(round(ad_bc[i].real() + ad_bc[i].imag())) %
kModulo;
int64 v2 = static_cast<int64>(round(ac_bd[i].real())) % kModulo;
result[i] = (v0 + v1 * z + v2 * z2) % kModulo;
}
return result;
}
vector<vector<int>> edges_;
vector<int> size_;
vector<vector<int>> state_;
};
void solve() {
int n;
scanf("%d", &n);
int64 x;
scanf("%I64d", &x);
Tree t(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d %d", &u, &v);
t.AddEdge(u - 1, v - 1);
}
cout << t.Calc(x) << "\n";
}
int main() {
solve();
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
long long int N,M,K,T,H,W,L,R;
int main()
{
cin>>N>>M>>K;
N=abs(N);
long long int num=N/K;
if(num>=M)
{
cout<<N-M*K;
return 0;
}
H=N%K;
if((M-num)&1)
{
cout<<K-H;
}
else
{
cout<<H;
}
} | 0 |
#include <algorithm>
#include <cstdio>
typedef long long LL;
const int N=5005,M=205;
LL a[N],sum[N],ans=0;
int p[M][N],v[M][N],t[M],n,m;
int main(){
scanf("%d%d\n",&n,&m);
for (int i=2;i<=n;i++) scanf("%lld",&a[i]),a[i]+=a[i-1];
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++){
int x;
scanf("%d",&x);
for (;t[j] && v[j][t[j]]<=x;t[j]--){
sum[p[j][t[j]]]-=v[j][t[j]];
sum[p[j][t[j]-1]]+=v[j][t[j]];
}
sum[p[j][t[j]]]-=x;
v[j][++t[j]]=x;p[j][t[j]]=i;
sum[i]+=x;
}
LL s=0;
for (int j=i;j;j--){
s+=sum[j];
ans=std::max(ans,s-a[i]+a[j]);
}
}
printf("%lld\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1,m1,h2,m2,k;
cin >>h1 >>m1 >>h2 >>m2 >>k;
cout <<60*h2+m2-60*h1-m1-k;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef vector<vector<int>> graph;
ifstream in("buffcraft.in", ios::in);
ofstream out("buffcraft.out", ios::out);
int main() {
double m, R, ans = 0;
cin >> m >> R;
for (int x = 2; x < m; x++)
ans += ((x - 1) * 2 + 2 * sqrt(2.0)) * 2 * (m - x);
ans += 2 * m + (2 + sqrt(2.0)) * 2 * (m - 1);
cout << setprecision(15) << ans / (m * m) * R;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 300010;
int dp[NMAX][20];
int v[NMAX];
int dp2[20];
int n;
int main() {
int q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", v + i);
for (int b = 0; b < 20; b++) {
if (v[i] & (1 << b))
dp[i][b] = i;
else
for (int j = 0; j < 20; j++)
if (v[i] & (1 << j)) dp[i][b] = max(dp[i][b], dp[dp2[j]][b]);
}
for (int b = 0; b < 20; b++)
if (v[i] & (1 << b)) dp2[b] = i;
}
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
bool ok = 0;
for (int i = 0; i < 20; i++)
if ((v[a] & (1 << i)) && dp[b][i] >= a) ok = 1;
printf("%s\n", (ok ? "Shi" : "Fou"));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
void solve(){
int n; cin >> n;
ll x; cin >> x;
ll maxi = 0, mini = 1e18;
ll s = 0;
for (int i=0; i<n; i++){
ll ai; cin >> ai;
ll divi = (ai + x -1)/x;
maxi += divi;
s += ai;
}
mini = (s+x-1)/x;
cout << mini << ' ' << maxi << '\n';
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1; cin >> t;
while(t--) solve();
return 0;
}
// NK
| 1 |
#include <iostream>
using namespace std;
int main()
{
for(int w,h;cin>>w>>h,w|h;){
int ci=0,cj=0;
int di[]={0,1,0,-1},dj[]={1,0,-1,0},d=1;
for(;;){
string cmd; cin>>cmd;
if(cmd=="FORWARD"){
int n; cin>>n;
ci+=di[d]*n; cj+=dj[d]*n;
ci=max(ci,0); cj=max(cj,0);
ci=min(ci,h-1); cj=min(cj,w-1);
}
if(cmd=="BACKWARD"){
int n; cin>>n;
ci-=di[d]*n; cj-=dj[d]*n;
ci=max(ci,0); cj=max(cj,0);
ci=min(ci,h-1); cj=min(cj,w-1);
}
if(cmd=="RIGHT")
d=(d+3)%4;
if(cmd=="LEFT")
d=(d+1)%4;
if(cmd=="STOP"){
cout<<cj+1<<" "<<ci+1<<endl;
break;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200005];
map<long long, int> mpp;
int main() {
int n;
scanf("%d", &n);
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
sum += arr[i];
mpp[sum] = i;
}
long long bk = 0;
long long res = 0;
for (int i = n; i > 1; i--) {
bk += arr[i];
if (mpp[bk] != 0 && i > mpp[bk]) {
res = max(res, bk);
}
}
printf("%I64d ", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int mod = 1000000007;
int main() {
int n, k;
double tot = 0;
scanf("%d %d", &n, &k);
int i, j;
double t1;
for (i = 1; i <= n; i++) {
scanf("%lf", &t1);
tot = tot + t1;
}
double basictot = tot;
int add = 0;
while (1) {
double avg = tot / n;
avg = avg + 0.5;
int whavg = (int)(avg);
if (whavg >= k) break;
add++;
n++;
tot += k;
}
printf("%d\n", add);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a;
int l = 0, x;
for (int i = 1; i <= n; i++) a.push_back(i);
for (int j = 0; j < k; j++) {
cin >> x;
l = (l + x) % n;
cout << a[l] << " ";
a.erase(a.begin() + l);
n--;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, vf[5010];
bool ds[5010], dt[5010];
vector<long long> vt[5010], bk[5010];
vector<pair<long long, long long> > ed;
void dfs(long long x) {
long long i;
ds[x] = true;
for (i = 0; i < vt[x].size(); i++) {
if (!ds[vt[x][i]]) {
dfs(vt[x][i]);
}
}
return;
}
void dfs2(long long x) {
long long i;
dt[x] = true;
for (i = 0; i < bk[x].size(); i++) {
if (!dt[bk[x][i]]) {
dfs2(bk[x][i]);
}
}
return;
}
int main() {
long long i, j, x, y;
scanf("%lld%lld", &n, &m);
for (i = 0; i < m; i++) {
scanf("%lld%lld", &x, &y);
x--;
y--;
ed.push_back(make_pair(x, y));
vt[x].push_back(y);
bk[y].push_back(x);
}
memset(ds, false, sizeof(ds));
dfs(0);
memset(dt, false, sizeof(dt));
dfs2(n - 1);
memset(vf, 127, sizeof(vf));
vf[0] = 0;
for (j = 0; j <= n; j++) {
for (i = 0; i < ed.size(); i++) {
if (ds[ed[i].first] && dt[ed[i].second]) {
x = vf[ed[i].second];
y = vf[ed[i].first];
vf[ed[i].second] = min(vf[ed[i].second], y + 2);
vf[ed[i].first] = min(vf[ed[i].first], x - 1);
}
}
}
for (i = 0; i < m; i++) {
if (ds[ed[i].first] && dt[ed[i].second]) {
if (abs(vf[ed[i].second] - vf[ed[i].first]) != 1 &&
abs(vf[ed[i].second] - vf[ed[i].first]) != 2) {
puts("No");
return 0;
}
}
}
puts("Yes");
for (i = 0; i < ed.size(); i++) {
if ((!ds[ed[i].first]) || (!dt[ed[i].second])) {
puts("1");
} else {
printf("%lld\n", abs(vf[ed[i].second] - vf[ed[i].first]));
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long pw(long long b, long long p) {
if (!p) return 1;
long long sq = pw(b, p / 2);
sq *= sq;
if (p % 2) sq *= b;
return sq;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long sd(long long x) { return x < 10 ? x : x % 10 + sd(x / 10); }
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
string x;
int k, n, out = 1;
bool check(int i, int j) {
if (i >= n + k || j >= n + k) return 0;
if (i < n && j < n) return (x[i] == x[j]);
return 1;
}
int main() {
cin >> x >> k;
n = ((int)((x).size()));
for (int l = 2; l <= n + k; l += 2) {
for (int s = 0; s <= n + k; ++s) {
for (int i = s; i < s + l / 2; ++i)
if (!check(i, i + l / 2)) goto next;
out = l;
next:;
}
}
cout << out;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *A = new int[n];
int kol = 0;
int kolO = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (A[i] == 0) {
kolO++;
}
if (A[i] == 5) {
kol++;
}
}
if (kolO == 0) {
cout << -1 << endl;
return 0;
}
if (kol < 9) {
cout << 0 << endl;
return 0;
}
int t = kol % 9;
kol = kol - t;
t = kol + kolO;
string str = "";
for (int i = 0; i < t; i++) {
if (kol > 0) {
str += '5';
kol--;
} else {
str += '0';
}
}
cout << str << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 20;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double RATE = 0.995;
const double eps = 1e-6;
std::mt19937 rnd(time(0));
long long qpw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ans;
}
long long inv(long long a) { return qpw(a, MOD - 2); }
struct CombMath {
int C[1005][1005];
void init(int n) {
for (int i = 1; i <= n; ++i) C[i][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
};
char op[20];
signed main() {
while (true) {
scanf("%s", op);
if (op[0] == 's') {
printf("? 0 1\n");
fflush(stdout);
scanf("%s", op);
if (op[0] == 'x') {
printf("! 1\n");
fflush(stdout);
continue;
}
int x = 1, y = 2;
while (true) {
printf("? %d %d\n", x, y);
fflush(stdout);
scanf("%s", op);
if (op[0] == 'x') {
break;
} else {
x *= 2, y *= 2;
}
}
int l = x, r = y;
while (l < r) {
int m = l + r >> 1;
printf("? %d %d\n", m, r);
fflush(stdout);
scanf("%s", op);
if (m + 1 == r) {
if (op[0] == 'x')
l = r;
else
l = m;
break;
}
if (op[0] == 'x') {
l = m;
} else {
r = m;
}
}
printf("! %d\n", l);
fflush(stdout);
} else
break;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin>>str;
for(int i=0;i<str.size();i++){
cout<<"x";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
int sum;
int c;
for(int bit=0;bit<(1<<3);bit++){
sum=s[0]-'0';
for(int i=0;i<3;i++){
if(bit&(1<<i)){
sum+=s[i+1]-'0';
}
else{
sum-=s[i+1]-'0';
}
}
if(sum==7){c=bit;break;}
}
cout<<s[0];
for(int i=0;i<3;i++){
if(c&(1<<i)){
cout<<"+";
}
else{
cout<<"-";
}
cout<<s[i+1];
}
cout<<"=7"<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int res[13][2];
char tmp[10];
int main() {
int n;
scanf("%d", &n);
for (int j = 0; j < 10; j++) res[j][0] = 0, res[j][1] = 1;
for (int i = 1; i <= n; i++) {
int v;
scanf("%s%d", tmp, &v);
for (int j = 0; j < 10; j++) {
if (tmp[0] == '|') {
res[j][0] = (res[j][0] | (v >> j)) & 1;
res[j][1] = (res[j][1] | (v >> j)) & 1;
}
if (tmp[0] == '^') {
res[j][0] = (res[j][0] ^ (v >> j)) & 1;
res[j][1] = (res[j][1] ^ (v >> j)) & 1;
}
if (tmp[0] == '&') {
res[j][0] = (res[j][0] & (v >> j)) & 1;
res[j][1] = (res[j][1] & (v >> j)) & 1;
}
}
}
int v1 = 0, v2 = 0, v3 = 0;
for (int j = 0; j < 10; j++) {
if (res[j][0] == 0 && res[j][1] == 0)
v1 = v1 | (0 << j);
else
v1 = v1 | (1 << j);
if (res[j][0] == 1 && res[j][1] == 0)
v2 = v2 | (1 << j);
else
v2 = v2 | (0 << j);
if (res[j][0] == 1 && res[j][1] == 1)
v3 = v3 | (1 << j);
else
v3 = v3 | (0 << j);
}
printf("3\n");
printf("& %d\n", v1);
printf("^ %d\n", v2);
printf("| %d\n", v3);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, j, xi, yi;
cin >> n;
int x[n], v[n], mox = 0;
for (i = 0; i < n; i++) cin >> x[i];
for (i = 0; i < n; i++) cin >> v[i];
long double mid, low, high, t, mr, ml;
low = 0;
for (i = 0; i < n; i++) {
if (mox < x[i]) {
mox = x[i];
}
}
high = (long double)mox;
xi = 5;
while (i) {
mid = (long double)(high + low) / 2.0;
ml = 0;
mr = 0;
for (i = 0; i < n; i++) {
if (x[i] < mid) {
if ((long double)((mid - x[i]) / (long double)v[i]) > ml) {
ml = (long double)((mid - x[i]) / (long double)v[i]);
}
}
if (x[i] > mid) {
if ((long double)((x[i] - mid) / v[i]) > mr) {
mr = (long double)((x[i] - mid) / v[i]);
}
}
}
if (ml < mr) {
low = mid;
t = (long double)(mr - ml);
if (t < 0.000000001) {
t = (long double)(ml + mr) / 2.0;
break;
}
} else if (ml > mr) {
high = mid;
if (ml - mr < 0.000000001) {
t = (long double)(ml + mr) / 2.0;
break;
}
} else {
t = ml;
break;
}
xi--;
}
cout.precision(17);
cout << t;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const long long md=998244353;
long long n,m,k,ft[202020],ans;
long long pw(long long x,long long y)
{
long long ans=1;
while(y)
{
if(y&1)
{
ans*=x;
ans%=md;
}
y>>=1;
x*=x;
x%=md;
}
return ans;
}
long long chu(long long x)
{
return pw(x,md-2);
}
long long C(long long a,long long b)
{
return (ft[a]*chu(ft[b]*ft[a-b]%md))%md;
}
int main()
{
ft[0]=1;
ft[1]=1;
for(long long i=2;i<=200100;i++)
{
ft[i]=ft[i-1]*i;
ft[i]%=md;
}
cin>>n>>m>>k;
for(long long i=0;i<=k;i++)
{
long long rt=n-i-1,nw=m;
if(i!=0)
{
nw*=C(n-1,i);
nw%=md;
}
nw*=pw(m-1,rt);
nw%=md;
ans+=nw;
ans%=md;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)n; i++)
typedef long long ll;
typedef pair<int,int> P;
int main(){
int n;
cin >> n;
vector<P> p(n);
rep(i,n) {
int v;
cin >> v;
p.push_back(P(v,i+1));
}
sort(p.begin(),p.end(),greater<P>());
multiset<int> s;
s.insert(n+1); s.insert(n+1); s.insert(0); s.insert(0);
ll ans = 0;
rep(i,n){
int l = p[i].second;
s.insert(l);
ll w, x, y, z;
auto it = s.find(l);
auto jt = s.find(l);
x = *(--it);
w = *(--it);
y = *(++jt);
z = *(++jt);
ans += (ll)(n-i)*((x-w)*(y-l)+(l-x)*(z-y));
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define lli long long int
#define loop(i,a,b) for(lli i=a;i<b;i++)
#define loopb(i,a,b) for (lli i=a;i>=b;i--)
#define pb push_back
#define mod 1000000007
#define fast() ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define mem(a,b) memset(a,b,sizeof(a))
#define gcd(a,b) (__gcd((a),(b)))
#define lcm(a,b)(((a)*(b))/gcd((a),(b)))
#define bc __builtin_popcountll
#define vi vector<lli>
#define pr pair<lli,lli>
#define vp vector<pr>
#define F first
#define S second
#define lld long double
#define PI 3.14159265358979
#define pri priority_queue<lli>
#define prim priority_queue<lli,vector<lli>,greater<lli>>
#define prip priority_queue<pr>
#define primp priority_queue<pr,vector<pr>,greater<pr>>
#define flush cout<<flush
int main(){
lli t,n;
cin>>t;
while(t--){
cin>>n;
lli a[n];
lli st = 9;
a[0] = 9;
loop(i,1,3){
if( i > (n-1)){
break;
}
else{
if(i==1)a[i] = 8;
if(i==2)a[i] = 9;
}
}
st = 0;
loop(i,3,n){
a[i] = st;
st = st + 1;
if(st == 10)st = 0;
}
loop(i,0,n){
cout<<a[i];
}
cout<<"\n";
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char str[5];
vector<string> v;
stack<bool> s;
s.push(false);
while (scanf("%s", str) == 1) {
v.push_back(str);
if (!strcmp(str, "int")) {
while (!s.empty()) {
if (!s.top()) {
s.top() = true;
v.back() += ',';
break;
} else {
v.back() += '>';
s.pop();
}
}
} else {
s.push(false);
v.back() += '<';
}
}
if (s.size() != 1)
puts("Error occurred");
else {
v.back().pop_back();
for (auto x : v) printf("%s", x.c_str());
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long bip(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
n >>= 1;
}
return res;
}
const int maxn = 1e9;
const int mod = 998244353;
const int N = 2e5 + 10;
int n, c[N], num[N], k = 1, dist, x = 1;
vector<int> g[N], new_g[N];
void dfs(int v) {
num[v] = k;
for (int to : g[v]) {
if (!num[to] && c[to] == c[v]) {
dfs(to);
}
}
}
void dfs2(int v, int p) {
for (int to : g[v]) {
if (to == p) continue;
if (num[v] != num[to]) {
new_g[num[v]].push_back(num[to]);
new_g[num[to]].push_back(num[v]);
}
dfs2(to, v);
}
}
void dfs3(int v, int p, int d) {
if (d > dist) {
x = v;
dist = d;
}
for (auto to : new_g[v]) {
if (to == p) continue;
dfs3(to, v, d + 1);
}
}
void dfs4(int v, int p, int d) {
dist = max(dist, d);
for (auto to : new_g[v]) {
if (to == p) continue;
dfs4(to, v, d + 1);
}
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y), g[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!num[i]) {
dfs(i);
k++;
}
}
dfs2(1, -1);
dfs3(1, -1, 0);
dist = 0;
dfs4(x, -1, 0);
cout << (dist + 1) / 2;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int tt = 1;
while (tt--) {
solve();
cout << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double const pi = 3.1415926536;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int k = 0, s = 0;
for (int i = 0; i <= 1000000 / 2; i++) {
if (a[k] == i && k < n) {
s = a[k] - 1;
k++;
}
}
k = n - 1;
int c = 0;
for (int i = 1000000; i > 1000000 / 2; i--) {
if (i == a[k] && k >= 0) {
c = 1000000 - a[k];
k--;
}
}
cout << max(c, s);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcount(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
int n, a[400025], b[400025];
int add = 200010;
vector<int> V[400025];
long long res = 0;
int cal(int id) {
multiset<int> S1, S2;
multiset<int>::iterator it;
for (int i = 0; i < (n); ++i) {
int x = (a[i] - b[i] + add);
int y = a[i] + b[i];
if ((x & 1) != id) {
S1.insert(y);
}
}
for (int i = 1; i < 400025; i++)
if ((i & 1) == id) {
for (int j = 0; j < (((long long)(V[i - 1]).size())); ++j) {
S2.insert(V[i - 1][j]);
S1.erase(S1.find(V[i - 1][j]));
}
if (((long long)(S1).size()) && ((long long)(S2).size())) {
long long A1, A2, B1, B2;
it = S1.begin();
A1 = *it;
it = S1.end();
it--;
B1 = *it;
it = S2.begin();
A2 = *it;
it = S2.end();
it--;
B2 = *it;
long long add = max(0ll, min(B1, B2) - max(A1, A2)) / 2;
res += add;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int run = 0; run < (n); ++run) {
int u, v;
cin >> u >> v;
V[u - v + add].push_back(u + v);
a[run] = u;
b[run] = v;
}
for (int i = 0; i < (2); ++i) cal(i);
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool maximize(T &x, const T &y) {
if (x < y)
x = y;
else
return false;
return true;
}
const int N = 3e5 + 10;
int n;
long long res = 0;
int a[N];
pair<long long, long long> val[N], s[N], stand[N];
pair<long long, long long> Xor(pair<long long, long long> x,
pair<long long, long long> y) {
return {(x.first ^ y.first), (x.second ^ y.second)};
}
void CalcPrefix() {
s[0] = {0, 0};
for (int i = 1; i <= n; i++) s[i] = Xor(s[i - 1], val[a[i]]);
}
pair<long long, long long> get(int l, int r) { return Xor(s[r], s[l - 1]); }
int main() {
srand(time(NULL));
if (fopen("exam.inp", "r"))
freopen("exam.inp", "r", stdin), freopen("exam.out", "w", stdout);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) res++;
val[i] = {rand() % (long long)(1e18), rand() % (long long)(1e18)};
stand[i] = Xor(stand[i - 1], val[i]);
}
for (int ttry = 1; ttry <= 2; ttry++) {
CalcPrefix();
for (int i = 1; i <= n; i++)
if (a[i] == 1) {
int r = i + 1, len = a[i];
while (r <= n && a[r] != 1) {
maximize(len, a[r]);
if (get(r - len + 1, r) == stand[len]) res++;
r++;
}
}
reverse(a + 1, a + 1 + n);
}
cout << res;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int t1[1000005], a[1000005], b[1000005], pos[1000005], gs[1000005],
sk[1000005][2], mk[1000005], mx[1000005];
int n, m, bin, mnv, mxv, lwl, hl, tp, m1, m2, vl, vr, tpv;
bool iv;
inline int read() {
int n = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = n * 10 + c - '0';
c = getchar();
}
return n * f;
}
inline int lowbit(int x) { return x & -x; }
inline int getsum(int x) {
int lt = 0;
for (; x; x -= lowbit(x)) lt += t1[x];
return lt;
}
inline void getadd(int x) {
for (; x <= n; x += lowbit(x)) ++t1[x];
}
bool cmp1(int x, int y) { return a[x] < a[y] || a[x] == a[y] && x < y; }
int main() {
register int i;
n = read();
m = read();
for (i = 1; i <= n; ++i) a[i] = b[i] = read(), pos[i] = i;
sort(b + 1, b + n + 1);
bin = unique(b + 1, b + n + 1) - b - 1;
for (i = 1; i <= n; ++i) a[i] = lower_bound(b + 1, b + bin + 1, a[i]) - b;
sort(pos + 1, pos + n + 1, cmp1);
mnv = lwl = n + 1;
mxv = 0;
for (i = 1; i <= n; ++i) {
gs[pos[i]] = getsum(min(pos[i] + m, n)) - getsum(pos[i]) + (pos[i] + m > n);
getadd(pos[i]);
if (!gs[pos[i]])
mnv = min(mnv, pos[i]), mxv = max(mxv, pos[i]), lwl = min(lwl, a[pos[i]]);
}
if (mnv > mxv) return 0 * printf("YES");
if (mxv - mnv > m) return 0 * printf("NO");
hl = 1;
tp = 0;
for (i = 1; i < m + 1; ++i) {
for (; tp && a[i] <= sk[tp][0]; --tp)
;
++tp;
sk[tp][0] = a[i];
sk[tp][1] = i;
}
for (i = 1; i <= n; ++i) {
for (; hl <= tp && a[i + m] <= sk[tp][0]; --tp)
;
++tp;
sk[tp][0] = a[i + m];
sk[tp][1] = i + m;
if (sk[hl][1] == i) ++hl;
mk[i] = sk[hl][0];
}
if (mxv == mnv) {
m1 = m2 = n + 1;
for (i = mxv + 1; i <= mxv + m; ++i) m1 = min(m1, a[i]);
for (i = max(mnv - m, 1); i < mnv; ++i)
if (gs[i] == 1) m2 = min(a[i], m2);
for (i = 1; i < mnv; ++i)
if (m2 > a[i] && a[i] > m1 && a[mxv] > mk[i]) return 0 * printf("YES");
}
vl = mxv + 1;
vr = min(mnv + m, n);
if (vr == n) return 0 * printf("NO");
for (i = vl; i <= vr; ++i) mx[a[i]] = max(mx[a[i]], i);
for (i = 1; i <= n; ++i) mx[i] = max(mx[i - 1], mx[i]);
tp = 0;
for (i = vl; i <= vr; ++i) {
while (tp && a[i] < sk[tp][0]) --tp;
++tp;
sk[tp][0] = a[i];
sk[tp][1] = i;
}
for (i = vr + 1; i <= n; ++i) {
tpv = n + 1;
iv = true;
for (; tp && a[i] < sk[tp][0]; --tp)
if (gs[sk[tp][1]] == 1) tpv = sk[tp][0], iv = sk[tp][1] > vr ? false : iv;
++tp;
sk[tp][0] = a[i];
sk[tp][1] = i;
if (a[i] < lwl && mx[tpv - 1] && a[i] > mk[mx[tpv - 1]])
return 0 * printf("YES");
if (a[i] < lwl && iv && a[i] > mk[vr]) return 0 * printf("YES");
}
printf("NO");
}
| 6 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct Piece {
int w,d;
Piece(int w=0,int d=0) : w(w), d(d) {}
};
int main() {
int n, w, d;
while (cin >> n >> w>>d, n||w||d) {
vector<Piece> pieces(1);
pieces[0] = Piece(w,d);
for(int i =0; i<n; i++) {
int p,s;
cin >>p>>s;
p--;
Piece target = pieces[p];
pieces.erase(pieces.begin()+p );
int dir = 0;
int ds[] = {target.w, target.d, target.w, target.d};
while (ds[dir] < s) s -= ds[dir], dir = (dir + 1)%4;
Piece p1,p2;
if(dir%2==0) { // cut vertical
p1 = Piece(s, target.d);
p2 = Piece(target.w-s, target.d);
} else { // cut horizontal
p1 = Piece(target.w, s);
p2 = Piece(target.w, target.d-s);
}
if (p1.w*p1.d > p2.w*p2.d) swap(p1,p2);
pieces.push_back(p1);
pieces.push_back(p2);
}
vector<int> as;
for(int i =0;i < pieces.size();i++) as.push_back(pieces[i].w*pieces[i].d);
sort(as.begin(), as.end());
cout <<as[0];
for(int i = 1; i < pieces.size(); i++) {
//int sum = 0;
//while (ppieces[i].w*pieces[i].d == pieces[i+1].w*pieces[i+1].d)
cout << " "<<as[i];
}
cout<<endl;
}
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.