solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <iostream>
#include <string.h>
using namespace std;
int n, q, x, y, t;
int a[100000];
int main()
{
cin >> n >> q;
memset(a, 0, sizeof(a));
for (int i = 0; i < q; i++) {
cin >> t;
if (t == 0) {
cin >> x >> y;
a[x] += y;
}
else if (t == 1) {
cin >> x >> y;
int m = 0;
for (int j = x; j <= y; j++)
m += a[j];
cout << m << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int INF = 1e9 + 7;
char grid[2005][2005];
int dist[2005][2005];
bool good[2005][2005];
int main() {
int N, K;
scanf("%d %d", &N, &K);
for (int i = 0; i < N; i++) {
scanf("%s", grid[i]);
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
dist[i][j] = INF;
}
}
for (int r = 0; r < N; r++) {
for (int c = 0; c < N; c++) {
dist[r][c] = (r || c) ? INF : 0;
if (r) dist[r][c] = std::min(dist[r][c], dist[r - 1][c]);
if (c) dist[r][c] = std::min(dist[r][c], dist[r][c - 1]);
if (grid[r][c] != 'a') dist[r][c]++;
}
}
int far = -1;
for (int r = 0; r < N; r++) {
for (int c = 0; c < N; c++) {
if (dist[r][c] <= K) far = std::max(far, r + c);
}
}
for (int r = 0; r < N; r++) {
for (int c = 0; c < N; c++) {
if (dist[r][c] <= K && far == r + c) {
good[r][c] = true;
}
}
}
std::string str(far + 1, 'a');
if (far == -1) {
str += grid[0][0];
good[0][0] = true;
far = 0;
}
for (; far < (N - 1) * 2; far++) {
char next = 127;
for (int r = 0; r < N; r++) {
int c = far - r;
if (c < 0 || c >= N || !good[r][c]) continue;
if (r + 1 < N) next = std::min(next, grid[r + 1][c]);
if (c + 1 < N) next = std::min(next, grid[r][c + 1]);
}
for (int r = 0; r < N; r++) {
int c = far - r;
if (c < 0 || c >= N || !good[r][c]) continue;
if (r + 1 < N && next == grid[r + 1][c]) good[r + 1][c] = true;
if (c + 1 < N && next == grid[r][c + 1]) good[r][c + 1] = true;
}
str += next;
}
printf("%s\n", str.c_str());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10, MAX = 2000, MOD = 1e9 + 7;
void OUT(long double o, int x) {
cout << fixed << setprecision(x) << o;
return;
}
long long dp[MAX][MAX], dp1[MAX][MAX];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
a = "0" + a;
b = "0" + b;
for (int i = 1; i < a.size(); i++) dp[i][0] = i, dp1[i][0] = 1;
for (int i = 1; i < b.size(); i++) dp[0][i] = i, dp1[0][i] = 2;
for (int i = 1; i < a.size(); i++) {
for (int j = 1; j < b.size(); j++) {
long long x = dp[i - 1][j - 1];
if (a[i] != b[j]) x++;
x = min(x, dp[i - 1][j] + 1);
x = min(x, dp[i][j - 1] + 1);
dp[i][j] = x;
if (a[i] != b[j] && x == dp[i - 1][j - 1] + 1) dp1[i][j] = 3;
if (x == dp[i - 1][j] + 1) dp1[i][j] = 1;
if (x == dp[i][j - 1] + 1) dp1[i][j] = 2;
}
}
cout << dp[a.size() - 1][b.size() - 1] << "\n";
long long x = a.size() - 1, y = b.size() - 1;
while (x > 0 || y > 0) {
if (dp1[x][y] == 0)
x--, y--;
else if (dp1[x][y] == 1) {
cout << "DELETE " << x << "\n";
x--;
} else if (dp1[x][y] == 2) {
cout << "INSERT " << x + 1 << " " << b[y] << "\n";
y--;
} else {
cout << "REPLACE " << x << " " << b[y] << "\n";
x--, y--;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5000 + 5;
int A, B;
char a[MAX_N], b[MAX_N];
int ans, f[MAX_N][MAX_N];
int main() {
scanf("%d%d", &A, &B);
scanf("%s%s", a + 1, b + 1);
for (int i = 1; i <= A; i++) {
for (int j = 1; j <= B; j++) {
if (a[i] == b[j]) {
f[i][j] = f[i - 1][j - 1] + 2;
} else {
f[i][j] = max(f[i][j], f[i][j - 1] - 1);
f[i][j] = max(f[i][j], f[i - 1][j] - 1);
}
ans = max(ans, f[i][j]);
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long LINF = 2e16;
const int INF = 2e9;
const int magic = 348;
const double eps = 1e-10;
const double pi = 3.14159265;
inline int getint() {
char ch;
int res;
bool f;
while (!isdigit(ch = getchar()) && ch != '-') {
}
if (ch == '-')
f = false, res = 0;
else
f = true, res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return f ? res : -res;
}
int n;
struct POINT {
double first, second;
inline void input() {
first = getint();
second = getint();
}
} a[40048];
struct LINE {
double A, B, C;
};
inline double myabs(double first) {
return first >= double(0) ? first : -first;
}
inline LINE construct_line(POINT first, POINT second) {
LINE res;
res.A = second.second - first.second;
res.B = first.first - second.first;
res.C = first.second * second.first - first.first * second.second;
return res;
}
inline double calc_dist(POINT first, POINT second) {
return sqrt((first.first - second.first) * (first.first - second.first) +
(first.second - second.second) * (first.second - second.second));
}
inline POINT find_intersect(LINE l1, LINE l2) {
POINT res;
res.first = (l2.C * l1.B - l1.C * l2.B) / (l1.A * l2.B - l2.A * l1.B);
res.second = (l1.C * l2.A - l2.C * l1.A) / (l1.A * l2.B - l2.A * l1.B);
return res;
}
inline POINT OnTheLine(LINE l, POINT pt) {
if (l.B == 0) return POINT{-l.C / l.A, pt.second};
if (l.A == 0) return POINT{pt.first, -l.C / l.B};
double k = double(-1) / (-l.A / l.B);
double b = pt.second - k * pt.first;
LINE tmp;
tmp.A = -k;
tmp.B = 1;
tmp.C = -b;
return find_intersect(l, tmp);
}
inline int inc(int first) { return first % n + 1; }
inline int dec(int first) {
first--;
return !first ? n : first;
}
void change_direction() { reverse(a + 1, a + n + 1); }
inline bool sameside(POINT pt1, POINT pt2, POINT pt3) {
if (pt1.first == pt2.first && pt1.first == pt3.first) {
if ((pt1.second >= pt3.second && pt2.second >= pt3.second) ||
(pt1.second <= pt3.second && pt2.second <= pt3.second))
return true;
else
return false;
} else {
if ((pt1.first >= pt3.first && pt2.first >= pt3.first) ||
(pt1.first <= pt3.first && pt2.first <= pt3.first))
return true;
else
return false;
}
}
inline bool islowpt(LINE l, POINT starter, int cur) {
int cmp = inc(cur);
POINT tmp1 = OnTheLine(l, a[cur]), tmp2 = OnTheLine(l, a[cmp]);
if (!sameside(tmp1, tmp2, starter)) return true;
double d1 = calc_dist(starter, tmp1), d2 = calc_dist(starter, tmp2);
return d1 > d2;
}
inline double calc_area(int ind1, int ind2, int ind3) {
double x1 = a[ind2].first - a[ind1].first,
y1 = a[ind2].second - a[ind1].second;
double x2 = a[ind3].first - a[ind1].first,
y2 = a[ind3].second - a[ind1].second;
double res = myabs(x1 * y2 - x2 * y1);
return res / 2;
}
double ans = 2e16;
void solve() {
double lastarea, curarea;
int lowpt, lastlowpt, tmppt, i;
lastlowpt = -1;
for (i = 1; i <= n; i++) {
LINE cur = construct_line(a[i], a[inc(i)]);
if (lastlowpt == -1)
lowpt = inc(i);
else
lowpt = lastlowpt;
while (!islowpt(cur, a[i], lowpt)) lowpt = inc(lowpt);
double len1 = calc_dist(OnTheLine(cur, a[lowpt]), a[lowpt]),
len2 = calc_dist(OnTheLine(cur, a[lowpt]), a[i]);
if (lastlowpt == -1) {
curarea = 0;
for (tmppt = inc(i); tmppt != lowpt; tmppt = inc(tmppt))
curarea += calc_area(i, tmppt, inc(tmppt));
ans = min(ans, len1 * len2 / 2 - curarea);
} else {
curarea = lastarea;
curarea -= calc_area(i - 1, i, lastlowpt);
for (tmppt = lastlowpt; tmppt != lowpt; tmppt = inc(tmppt))
curarea += calc_area(i, tmppt, inc(tmppt));
ans = min(ans, len1 * len2 / 2 - curarea);
}
lastlowpt = lowpt;
lastarea = curarea;
}
}
int main() {
int i;
n = getint();
for (i = 1; i <= n; i++) a[i].input();
solve();
change_direction();
solve();
printf("%.6lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 500005;
const long long linf = LLONG_MAX;
const long long mod = 1e9 + 7;
const int inf = INT_MAX;
long long t, x, y, a, b;
int main() {
cin >> t;
while (t--) {
cin >> x >> y >> a >> b;
cout << 1 + ((a - x) * (b - y)) << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
int fa[10000000 + 10];
inline long long gcd(long long a, long long b) {
while (a > 0) {
long long tmp = a;
a = b % a;
b = tmp;
}
return b;
}
inline void getfa(int a) {
int f = a, w;
while (fa[f] != f) f = fa[f];
while (fa[a] != a) {
w = fa[a];
fa[a] = f;
a = w;
}
}
int n;
inline void m(long long a, long long b) {
if (fa[a] == 0 || fa[b] == 0) return;
getfa(a);
getfa(b);
if (fa[a] == fa[b]) return;
fa[fa[a]] = fa[b];
n--;
}
int main() {
scanf("%d", &n);
int mx = 0;
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
fa[tmp] = tmp;
if (mx < tmp) mx = tmp;
}
for (long long i = 2; i * i <= 2 * mx; i += 2)
for (long long j = i + 1, a = i / 2 * (j + 1), b = j, c = i / 2 * i + j;
a <= mx && b <= mx; j += 2, a += i, b += j, c += j) {
if (gcd(a, b) > 1) continue;
m(a, b);
if (c <= mx) {
m(b, c);
m(c, a);
}
}
printf("%d\n", n);
}
| 4 |
#include "bits/stdc++.h"
#include<unordered_map>
#pragma warning(disable:4996)
using namespace std;
const int My_Inf = 2147483647;
const long long int My_LInf = 9223372036854775807;
struct plant {
double fertrate;
double lovewater;
double vital;
};
double pw;
vector<plant>plants;
double getmon(const double water) {
double ans = water*pw;
for (auto p:plants) {
double rest = p.vital - water*p.lovewater;
if (rest < 0) {
ans += 0;
}
else {
ans += rest / p.fertrate;
}
}
return ans;
}
int main() {
while (1) {
plants.clear();
int N; cin >> N; if (!N)break;
cin >> pw;
for (int i = 0; i < N; ++i) {
double vw, pf, vf, t; cin >> vw >> pf >> vf >> t;
double fertrate = vf / pf;
double water= vw;
plants.push_back(plant{ fertrate,water,t });
}
double amin = 0;
double amax = 100;
while (amin < amax - 1e-10) {
double amid1 = (amin * 2 + amax) / 3;
double amid2 = (amin + amax * 2) / 3;
double mon1 = getmon(amid1);
double mon2 = getmon(amid2);
if (mon1 < mon2) {
amax = amid2;
}
else {
amin = amid1;
}
}
double ans = getmon((amin+amax)/2);
cout <<setprecision(22)<<fixed<< ans << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll f(ll x){if(x==0) return 0;else return x%10+f(x/10);}
int main(){
std::ios::sync_with_stdio(false);
int k;cin>>k;
int num=0;ll ans=1;ll p=1;
while(num<k){
cout<<ans<<endl;
ll ans1=ans+p;
ll ans2=ans+p*10;
if(ans1*f(ans2)<=ans2*f(ans1)){ans=ans1;}
else{ans=ans2;p*=10;}
num++;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void init(T& x) {
x = 0;
char ch = getchar();
bool t = 0;
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') t = 1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + (ch - 48);
if (t) x = -x;
return;
}
const int N = 2e5 + 10;
long long S = 0;
int n;
long long a[N], b[N], c[N], d[N];
long long nb[N], nc[N];
int main() {
init(n);
for (int i = 1; i <= n; ++i) init(b[i]);
for (int i = 1; i <= n; ++i) init(c[i]);
for (int i = 1; i <= n; ++i) {
d[i] = b[i] + c[i];
S += d[i];
}
if (S % (n << 1)) return puts("-1"), 0;
S /= n << 1;
for (int i = 1; i <= n; ++i) {
if ((d[i] - S) % n) return puts("-1"), 0;
a[i] = (d[i] - S) / n;
if (a[i] < 0) return puts("-1"), 0;
}
for (int k = 0; k <= 30; ++k) {
int cnt = 0;
for (int i = 1; i <= n; ++i)
if ((a[i] >> k) & 1) ++cnt;
for (int i = 1; i <= n; ++i) {
if ((a[i] >> k) & 1) {
nb[i] += (1ll << k) * cnt;
nc[i] += (1ll << k) * n;
} else {
nc[i] += (1ll << k) * cnt;
}
}
}
for (int i = 1; i <= n; ++i) {
if ((b[i] ^ nb[i]) || (c[i] ^ nc[i])) return puts("-1"), 0;
}
for (int i = 1; i <= n; ++i) printf("%lld ", a[i]);
puts("");
return 0;
}
| 6 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
#define mp make_pair
#define pb push_back
#define ll long long
#define maxN 111
const int val = 100;
int A, B, i, j, n, m;
int v[maxN][maxN];
int least[maxN][maxN];
vector< pair<pair<int, int>, int> > edges;
void execute(int x, int y, int need) {
int i, j;
for (i = 0; i <= val; i++)
for (j = 0; j <= val; j++)
least[i][j] = max(least[i][j], need - (x * i + y * j));
}
bool check(int x, int y, int need) {
int i, j;
int act = 1 << 30;
for (i = 0; i <= val; i++)
for (j = 0; j <= val; j++)
act = min(act, i * x + j * y + least[i][j]);
if (act != need) return false;
return true;
}
void add_edge(int x, int y, int v) {
edges.pb(mp(mp(x, y), v));
m++;
}
int main()
{
// freopen("test.in","r",stdin);
// freopen("test.out","w",stdout);
cin >> A >> B;
for (i = 1; i <= A; i++) {
for (j = 1; j <= B; j++) {
cin >> v[i][j];
execute(i, j, v[i][j]);
}
}
for (i = 1; i <= A; i++) {
for (j = 1; j <= B; j++) {
if (!check(i, j, v[i][j])) {
cout << "Impossible";
return 0;
}
}
}
cout << "Possible\n";
add_edge(1, 2, 0);
for (i = 2; i + 1 <= val + 2; i++)
add_edge(i, i + 1, -1);
for (i = val + 3; i + 1 <= 2 * val + 3; i++)
add_edge(i + 1, i, -2);
add_edge(val + 3, 2 * val + 4, 0);
for (i = 0; i <= val; i++)
for (j = 0; j <= val; j++)
add_edge(i + 2, j + val + 3, least[i][j]);
n = 2 * val + 4;
cout << n << ' ' << m << '\n';
for (auto e : edges) {
cout << e.first.first << ' ' << e.first.second << ' ';
if (e.second == -1) cout << "X\n";
if (e.second == -2) cout << "Y\n";
if (e.second >= 0) cout << e.second << "\n";
}
cout << 1 << ' ' << n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long INF = 2e9;
const long long MOD = 1e9 + 7;
const long long MB = 20;
vector<vector<long long>> g;
vector<long long> a, s;
void dfs(long long v, long long p = -1) {
a.push_back(v);
s[v] = 1;
for (long long u : g[v]) {
if (u != p) {
dfs(u, v);
s[v] += s[u];
}
}
}
bool cmp(pair<long long, pair<long long, long long>>& one,
pair<long long, pair<long long, long long>>& two) {
return one.second.second < two.second.second;
}
void solve() {
long long n;
cin >> n;
vector<long long> b(n);
for (long long i = 0; i < n; i++) {
cin >> b[i];
b[i]--;
}
g.resize(n);
for (long long i = 0; i < n - 1; i++) {
long long from, to;
cin >> from >> to;
from--;
to--;
g[from].push_back(to);
g[to].push_back(from);
}
s.resize(n);
dfs(0);
long long k = 300;
vector<vector<pair<long long, pair<long long, long long>>>> q(n / k + 1);
for (long long i = 0; i < n; i++) {
long long id = a[i];
long long l = i;
long long r = l + s[id] - 1;
q[l / k].push_back({id, {l, r}});
}
for (long long i = 0; i < q.size(); i++) {
sort(q[i].begin(), q[i].end(), cmp);
}
for (long long& i : a) i = b[i];
vector<long long> ans(n);
for (long long i = 0; i < q.size(); i++) {
if (q[i].empty()) continue;
long long left = q[i][0].second.first;
long long right = q[i][0].second.second;
long long mx = 0;
vector<long long> now(n);
vector<long long> bb(n + 1);
for (long long j = left; j <= right; j++) {
long long id = a[j];
bb[now[id]] -= (id + 1);
now[id]++;
bb[now[id]] += (id + 1);
if (now[id] > mx) {
mx = now[id];
}
}
for (auto& p : q[i]) {
long long l = p.second.first;
long long r = p.second.second;
while (right < r) {
right++;
long long id = a[right];
bb[now[id]] -= (id + 1);
now[id]++;
bb[now[id]] += (id + 1);
if (now[id] > mx) {
mx = now[id];
}
}
while (left < l) {
long long id = a[left];
bb[now[id]] -= (id + 1);
if (!bb[now[id]] && mx == now[id]) mx--;
now[id]--;
bb[now[id]] += (id + 1);
left++;
}
while (left > l) {
left--;
long long id = a[left];
bb[now[id]] -= (id + 1);
now[id]++;
bb[now[id]] += (id + 1);
if (now[id] > mx) {
mx = now[id];
}
}
ans[p.first] = bb[mx];
}
}
for (long long i : ans) cout << i << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout.precision(12);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[int(1e5 + 5)], t, i, m, ans, k, l, j, x, n, ma, mi, N, F, f[int(1e5 + 5)],
H[int(1e5 + 5)];
string s[int(1e5 + 5)];
vector<int> g[int(1e5 + 5)];
queue<int> q;
int ch(int x) {
for (int i = 0; i < N; i++)
if (a[i] == x) return 1;
return 0;
}
void go(int u) {
a[N++] = u;
for (int i = 0; i < g[u].size(); i++) {
if (F) return;
if (f[g[u][i]] == 0) {
f[g[u][i]] = f[u] + 1;
go(g[u][i]);
} else {
if (ch(g[u][i])) {
F = 1;
return;
}
}
}
N--;
}
vector<char> AN;
int main() {
cin >> n;
for (i = 0; i < n; i++) cin >> s[i];
for (i = 1; i < n; i++) {
j = 0;
while (j < s[i].size() && j < s[i - 1].size() && s[i][j] == s[i - 1][j])
j++;
if (j >= s[i].size() || j >= s[i - 1].size()) {
if (s[i].size() == j && j < s[i - 1].size()) {
cout << "Impossible" << endl;
return 0;
}
continue;
}
H[s[i][j] - 'a']++;
g[s[i - 1][j] - 'a'].push_back(s[i][j] - 'a');
}
for (int i = 0; i < 26; i++)
if (!f[i]) go(i);
if (F) {
cout << "Impossible" << endl;
return 0;
}
for (int i = 0; i < 26; i++)
if (!H[i]) q.push(i);
while (!q.empty()) {
int w = q.front();
q.pop();
AN.push_back(char(w + 'a'));
for (int i = 0; i < g[w].size(); i++) {
H[g[w][i]]--;
if (H[g[w][i]] == 0) q.push(g[w][i]);
}
}
if (AN.size() != 26) {
cout << "Impossible" << endl;
return 0;
}
for (int i = 0; i < AN.size(); i++) cout << AN[i];
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double a, b[1000], c = 0;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b[i];
c += b[i];
}
size_t save_prec = cout.precision();
cout << setprecision(12) << fixed << c / a;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c;
cin >> d >> e >> f;
int dis = (abs(d - a) * abs(d - a) + abs(e - b) * abs(e - b) +
abs(f - c) * abs(f - c));
if (dis < 3)
cout << "YES";
else
cout << "NO";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, k;
cin >> n >> k;
string s;
cin >> s;
char clr[k];
for (int i = 0; i < k; i++) {
clr[i] = 65 + i;
}
if (k > 2) {
int noc = 0;
for (int i = 1; i < s.length() - 1; i++) {
if (s[i] == s[i - 1]) {
for (int j = 0; j < k; j++) {
if (clr[j] != s[i + 1] && clr[j] != s[i - 1]) {
s[i] = clr[j];
noc++;
break;
}
}
}
}
n = s.length();
if (s[0] == s[1]) {
int i = 0;
for (int j = 0; j < k; j++) {
if (clr[j] != s[i + 1]) {
s[i] = clr[j];
noc++;
break;
}
}
}
if (s[n - 1] == s[n - 2]) {
for (int j = 0; j < k; j++) {
if (clr[j] != s[n - 2]) {
s[n - 1] = clr[j];
noc++;
break;
}
}
}
cout << noc << endl;
cout << s;
} else {
string s1, s2;
s1 = s;
s2 = s;
s1[0] = 'A';
s2[0] = 'B';
for (int i = 1; i < s.length(); i++) {
if (s1[i - 1] == 'A')
s1[i] = 'B';
else
s1[i] = 'A';
if (s2[i - 1] == 'A')
s2[i] = 'B';
else
s2[i] = 'A';
}
int n1 = 0;
int n2 = 0;
for (int i = 0; i < n; i++) {
if (s[i] != s1[i]) n1++;
if (s[i] != s2[i]) n2++;
}
if (n1 < n2) {
cout << n1 << endl << s1;
} else {
cout << n2 << endl << s2;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long r, l, k, n;
long long dig1[33], dig2[33];
long long dp[33][2][2];
long long t[20];
long long dfs(long long pos, long long lit1, long long lit2) {
if (pos == 30) return 1;
if (dp[pos][lit1][lit2] != -1) return dp[pos][lit1][lit2];
long long u = lit1 ? dig1[pos] : 1;
long long v = lit2 ? dig2[pos] : 1;
long long x = 0;
for (long long i = 0; i <= u; i++) {
for (long long j = 0; j <= v; j++) {
if (i & j) continue;
x += dfs(pos + 1, i == u && lit1, j == v && lit2);
}
}
return dp[pos][lit1][lit2] = x;
}
long long sl(long long a, long long b) {
if (a == -1 || b == -1) return 0;
memset(dig1, 0, sizeof dig1);
memset(dig2, 0, sizeof dig2);
memset(dp, -1, sizeof dp);
for (long long i = 0; i < 30; i++) {
dig1[i] = a % 2;
a /= 2;
dig2[i] = b % 2;
b /= 2;
}
reverse(dig1, dig1 + 30);
reverse(dig2, dig2 + 30);
return dfs(0, 1, 1);
}
int main() {
long long T;
scanf("%lld", &T);
while (T--) {
memset(dp, -1, sizeof dp);
long long l, r;
scanf("%lld %lld", &l, &r);
printf("%lld\n", sl(r, r) + sl(l - 1, l - 1) - sl(r, l - 1) - sl(l - 1, r));
}
}
| 6 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <functional>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define rep1(i,n) for(int i=1;i<=(n);++i)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl;
struct edge{int to,cost,teki;};
typedef pair<int,int> P;
int n,m,l,inf=1e8;
int d[10100];
vector<edge> G[100];
void dijkstra(int s){
rep(i,n*101) d[i]=inf;
d[s]=0;
priority_queue<P,vector<P>,greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P p=que.top();
que.pop();
int v=p.sc,vn=v/101,vl=v%101;
if(d[v]<p.fs) continue;
rep(i,G[vn].size()){
edge e=G[vn][i];
int nn=e.to;
if(d[nn*101+vl]>d[v]+e.teki){
d[nn*101+vl]=d[v]+e.teki;
que.push(P(d[nn*101+vl],nn*101+vl));
}
if(vl>=e.cost){
int nl=vl-e.cost,to=nn*101+nl;
if(d[to]>d[v]){
d[to]=d[v];
que.push(P(d[to],to));
}
}
}
}
}
int main(){
while(true){
cin>>n>>m>>l;
if(n==0) break;
rep(i,n) G[i].clear();
rep(i,m){
int a,b,d,e;
cin>>a>>b>>d>>e;
a--,b--;
G[a].pb({b,d,e});
G[b].pb({a,d,e});
}
dijkstra(l);
int ans=inf;
rep(i,l+1) ans=min(ans,d[(n-1)*101+i]);
cout << ans <<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long nwd(long long a, long long b) { return !b ? a : nwd(b, a % b); }
bool used[1007];
struct cmp {
bool operator()(const pair<int, int> &P1, const pair<int, int> &P2) const {
if (P1.first > P2.first) return true;
if (P1.first < P2.first) return false;
if (used[P1.second] > used[P2.second]) return true;
if (used[P1.second] < used[P2.second]) return false;
return P1.second < P2.second;
return false;
}
};
int main() {
int n, k;
scanf("%d %d", &n, &k);
int A[1007];
for (int i = 0; i < (k); i++) scanf("%d", &A[i]);
set<pair<int, int>, cmp> S;
for (int i = 0; i < (k); i++) S.insert(make_pair(A[i], i + 1));
vector<int> ans;
for (int i = 0; i < n; i++) {
if (S.empty()) break;
if (ans.size() == 0 ||
(ans.size() > 0 && ans[ans.size() - 1] != (*(S.begin())).second)) {
if ((*S.begin()).first <= 0) break;
ans.push_back((*S.begin()).second);
pair<int, int> P = *S.begin();
used[P.second] = 1;
S.erase(S.begin());
P.first--;
if (P.first > 0) S.insert(P);
} else {
set<pair<int, int>, cmp>::iterator it = S.begin();
it++;
if (it == S.end()) break;
if ((*it).first <= 0) break;
ans.push_back((*it).second);
pair<int, int> P = *it;
used[P.second] = 1;
S.erase(it);
P.first--;
if (P.first > 0) S.insert(P);
}
}
if (ans[ans.size() - 1] == ans[0])
while (!S.empty()) {
if ((*S.begin()).second != ans[ans.size() - 2] &&
((*S.begin()).second != ans[0]) && (*S.begin()).first != 0)
ans[ans.size() - 1] = (*S.begin()).second;
S.erase(S.begin());
}
if (ans[ans.size() - 1] == ans[0]) ans.pop_back();
if (ans.size() != n) {
printf("-1");
return 0;
}
for (int i = 0; i < (ans.size()); i++) printf("%d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000010], b[11][1000010 + 1];
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long i, j;
for (i = 1; i <= 9; i++) {
a[i] = i;
}
for (i = 10; i < 1000010; i++) {
long long x = i;
long long c = 1;
while (x) {
long long y = x % 10;
if (y) c *= y;
x /= 10;
}
a[i] = a[c];
}
for (i = 0; i < 10; i++) {
b[i][0] = 0;
}
for (j = 1; j < 10; j++) {
long long c = 0;
for (i = 1; i < 1000010; i++) {
if (a[i] == j) c++;
b[j][i] = c;
}
}
int q;
cin >> q;
while (q--) {
long long l, r, k;
cin >> l >> r >> k;
long long ans = b[k][r] - b[k][l - 1];
printf("%lld\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <class T>
int size(T &&x) {
return int(x.size());
}
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <class T>
auto operator<<(ostream &out, T &&x) -> decltype(x.begin(), out) {
out << '{';
for (auto it = x.begin(); it != x.end(); ++it)
out << *it << (it == prev(x.end()) ? "" : ", ");
return out << '}';
}
void dump() {}
template <class T, class... Args>
void dump(T &&x, Args... args) {
cerr << x << "; ";
dump(args...);
}
mt19937_64 rng(0);
int rd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
int n, k;
vector<vector<pair<int, int>>> graph;
vector<vector<LL>> dp;
void dfs(int v = 0, int p = -1) {
vector<LL> delta;
LL sumnoup = 0;
for (auto e : graph[v])
if (e.first != p) {
int u = e.first;
dfs(u, v);
delta.emplace_back(dp[1][u] + e.second - dp[0][u]);
sumnoup += dp[0][u];
}
for (LL &x : delta) x = max(x, 0LL);
sort(delta.rbegin(), delta.rend());
0 && cerr;
0 && cerr;
for (int it = (0); it <= ((2) - 1); ++it) {
int sons = (it == 0 ? k : k - 1);
if (size(delta) > sons) delta.resize(sons);
LL sumdelta = 0;
for (LL x : delta) sumdelta += x;
dp[it][v] = sumnoup + sumdelta;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
while (q-- > 0) {
cin >> n >> k;
graph.clear();
graph.resize(n);
for (int edge = (0); edge <= ((n - 1) - 1); ++edge) {
int v, u, w;
cin >> v >> u >> w;
--v, --u;
graph[v].emplace_back(u, w);
graph[u].emplace_back(v, w);
}
dp.clear();
dp.resize(2, vector<LL>(n));
dfs(0);
0 && cerr;
cout << max(dp[0][0], dp[1][0]) << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long start_diff(long long k) { return k * (k - 1) / 2; }
pair<long long, long long> gen_bucket(long long diff, long long k) {
long long cnt = (diff - 1) / k;
diff -= 1ll * cnt * k;
return make_pair(cnt, k - (diff - 1));
}
vector<int> gen_bucket_old(long long diff, int k) {
int cnt = (diff - 1) / k;
diff -= 1ll * cnt * k;
vector<int> res(cnt, 0);
res.push_back(k - (diff - 1));
res.push_back(diff - 1);
for (int i = 0; i < k - cnt - 2; ++i) {
res.push_back(0);
}
return res;
}
long long get_inner_diff(pair<int, int> bucket, long long pos, long long k) {
long long cnt, add;
tie(cnt, add) = bucket;
if (pos <= cnt) {
return -pos;
} else if (pos == cnt + 1) {
return add - pos;
} else {
return k - pos;
}
}
long long get_total_sums(pair<int, int> bucket, long long bid, long long bpos,
long long k) {
long long cnt, add;
tie(cnt, add) = bucket;
long long len = 1ll * k * k;
long long pos = bpos / (len + 1);
long long spos = bpos % (len + 1);
long long bad_pos = start_diff(k) - 1 + get_inner_diff(bucket, pos, k);
if (spos == bad_pos) {
return -1ll;
}
long long total_sums = 1 + bid * k * k + 1ll * k * pos;
if (spos > bad_pos) {
total_sums += (spos - 1) / k;
} else {
total_sums += spos / k;
}
long long total_buckets = bid * k + pos;
if (spos > bad_pos) {
total_buckets++;
}
return total_sums - total_buckets;
}
pair<long long, long long> gen_bucket_rec(long long bid, long long k) {
if (bid == 0) {
return gen_bucket(start_diff(k), k);
} else {
long long par_bid = bid / k;
long long inn_id = bid % k;
auto bpar = gen_bucket_rec(par_bid, k);
long long inner_start_diff =
start_diff(k) + get_inner_diff(bpar, inn_id, k);
return gen_bucket(inner_start_diff, k);
}
}
long long find_gen(long long n, long long k) {
n -= 1ll * k * (k - 1) / 2;
return n / k;
}
long long solve(long long n, long long k) {
if (n <= k) return n;
long long diff = 1ll * k * (k - 1) / 2;
long long blen = (1ll * k * k + 1) * k;
long long bid = (n - k - 1) / blen, bpos = (n - k - 1) % blen;
auto bucket = gen_bucket_rec(bid, k);
long long total_sums = get_total_sums(bucket, bid, bpos, k);
if (total_sums != -1) {
return n + total_sums;
} else {
return solve(find_gen(n, k), k) + k;
}
for (auto x : gen_bucket_old(diff, k)) {
cerr << x + k * k << ' ';
}
cerr << endl;
for (int i = 0; i < k; ++i) {
cerr << start_diff(k) + get_inner_diff(gen_bucket(start_diff(k), k), i, k)
<< ' ';
}
cerr << endl;
return 0;
}
long long solve_naive(long long n, int k) {
vector<long long> used;
int p = 0;
int res = 0;
for (int i = 1;;) {
long long sum = 0ll;
for (int _ = 0; _ < k; ++_) {
while (p < used.size() && used[p] == i) {
++i;
++p;
}
sum += i;
res++;
if (n == i) return res;
++i;
}
used.push_back(sum);
res++;
if (sum == n) return res;
}
}
int main() {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
long long k;
long long n;
cin >> n >> k;
cout << solve(n, k) << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a, x, y, m;
int k[5005];
int ind[5005];
vector<int> problems[5005];
pair<int, int> ans[200001];
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%I64d%I64d%I64d%I64d", &k[i], &a, &x, &y, &m);
problems[i].push_back(a);
for (j = 1; j < k[i]; j++) {
a = (a * x + y) % m;
problems[i].push_back(a);
}
ind[i] = 0;
}
int bef = 0;
int last = 0;
int bad = 0;
int best, idx;
while (true) {
best = 1000000001;
for (i = 0; i < n; i++) {
if (ind[i] < k[i] && problems[i][ind[i]] < best &&
problems[i][ind[i]] >= bef) {
best = problems[i][ind[i]];
idx = i;
}
}
if (best == 1000000001) {
for (i = 0; i < n; i++) {
if (ind[i] < k[i] && problems[i][ind[i]] < best) {
best = problems[i][ind[i]];
idx = i;
}
}
bad++;
}
if (best == 1000000001) break;
bef = problems[idx][ind[idx]];
ind[idx]++;
if (last <= 200000) ans[last++] = make_pair(bef, idx);
}
printf("%d\n", --bad);
if (last <= 200000) {
for (i = 0; i < last; i++)
printf("%d %d\n", ans[i].first, ans[i].second + 1);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 2, maxk = 42;
bool mark[maxk][maxn][maxn], mcol[maxk][maxk];
int dis[maxk][maxn][maxn], dx[] = {0, 0, 1, -1}, dy[] = {-1, 1, 0, 0}, n, m, k,
ans, q, r1, r2, c1, c2, ar[maxn][maxn];
vector<pair<int, int>> color[maxk];
pair<int, int> x;
bool check(int x, int y, int i) {
if (x + dx[i] > -1 && x + dx[i] < n && y + dy[i] > -1 && y + dy[i] < m)
return 1;
return 0;
}
void BFS(int col) {
queue<pair<int, int>> q;
for (int i = 0; i < color[col].size(); i++) q.push(color[col][i]);
while (q.size()) {
x = q.front();
q.pop();
if (!mcol[col][ar[x.first][x.second]]) {
for (int o = 0; o < color[ar[x.first][x.second]].size(); o++) {
pair<int, int> j = color[ar[x.first][x.second]][o];
if (!mark[col][j.first][j.second]) {
dis[col][j.first][j.second] = dis[col][x.first][x.second] + 1;
mark[col][j.first][j.second] = 1;
q.push(j);
}
}
mcol[col][ar[x.first][x.second]] = 1;
}
for (int i = 0; i < 4; i++)
if (check(x.first, x.second, i) &&
mark[col][x.first + dx[i]][x.second + dy[i]] == 0) {
mark[col][x.first + dx[i]][x.second + dy[i]] = 1;
dis[col][x.first + dx[i]][x.second + dy[i]] =
dis[col][x.first][x.second] + 1;
q.push({x.first + dx[i], x.second + dy[i]});
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> r1;
r1--;
ar[i][j] = r1;
color[r1].push_back({i, j});
mark[r1][i][j] = 1;
}
for (int i = 0; i < k; i++) BFS(i);
cin >> q;
while (q--) {
cin >> r1 >> c1 >> r2 >> c2;
r1--, r2--, c1--, c2--;
ans = abs(r1 - r2) + abs(c1 - c2);
for (int i = 0; i < k; i++)
ans = min(ans, dis[i][r1][c1] + dis[i][r2][c2] + 1);
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0;
cin >> n;
while (n--) {
string s;
cin >> s;
for (int i = 0; i < s.length() - 1; i++) {
if (s[i] == '+' && s[i + 1] == '+') {
count++;
}
if (s[i] == '-' && s[i + 1] == '-') {
count--;
}
}
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x, y, n, T;
int main() {
scanf("%d", &T);
for (int t = 1; t <= T; ++t) {
scanf("%d%d%d", &x, &y, &n);
n -= y;
x = n % x;
printf("%d\n", n - x + y);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, flag = 0;
char arr[510][510] = {0};
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%s", arr[i] + 1);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (arr[i][j] == 'S') {
if (arr[i][j + 1] == 'W' || arr[i][j - 1] == 'W' ||
arr[i + 1][j] == 'W' || arr[i - 1][j] == 'W') {
flag = 1;
break;
}
}
}
if (flag == 1) {
break;
}
}
if (!flag) {
printf("Yes\n");
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (arr[i][j] == '.') {
arr[i][j] = 'D';
}
printf("%c", arr[i][j]);
}
printf("\n");
}
} else {
printf("No\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ans[300001], n, m, x, y, z;
set<int> s;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n + 10; i++) s.insert(i);
set<int>::iterator it, k;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
for (it = s.lower_bound(x); (it != s.end()) && (*it <= y); it = k) {
k = it;
k++;
if (*it != z) {
ans[*it] = z;
s.erase(it);
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
string s1, s2;
int n;
int a[N], b[N];
int main() {
cin >> n >> s1 >> s2;
for (int i = 1; i <= n; i++) a[i] = s1[i - 1], b[i] = s2[i - 1];
int ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) continue;
ans++;
if (a[i + 1] != b[i + 1] && a[i] == b[i + 1] && a[i + 1] == b[i])
a[i + 1] = b[i + 1];
a[i] = b[i];
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, y;
cin >> t;
while (t--) {
cin >> n >> m;
int a[n][m];
map<int, int> ma;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
if (j == 0) {
ma[a[i][j]] = i + 1;
}
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
cin >> y;
if (ma[y] != 0) {
for (int k = 0; k < m; ++k) {
cout << a[ma[y] - 1][k] << " ";
}
cout << endl;
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<long long, long long> > ab;
map<long long, long long> first;
map<long long, long long> second;
map<pair<long long, long long>, long long> sub;
vector<long long int> sun_kaam;
long long x, y, n, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y;
ab.push_back(make_pair(x, y));
first[x]++;
second[y]++;
}
sort(ab.begin(), ab.end());
x = ab[0].first;
y = ab[0].second;
long long int t = 1;
for (vector<pair<long long, long long> >::iterator it = ab.begin() + 1;
it != ab.end(); ++it) {
if (it->first == x && it->second == y) {
t++;
} else {
sun_kaam.push_back(t);
t = 1;
x = it->first;
y = it->second;
}
}
sun_kaam.push_back(t);
vector<int> a;
for (map<long long, long long>::iterator it = first.begin();
it != first.end(); ++it)
ans += ((it->second) * (it->second - 1)) / 2;
for (map<long long, long long>::iterator it = second.begin();
it != second.end(); ++it)
ans += ((it->second) * (it->second - 1)) / 2;
for (vector<long long int>::iterator it = sun_kaam.begin();
it != sun_kaam.end(); ++it)
if (*it > 1) ans -= ((*it) * (*it - 1)) / 2;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double INF = 1000000;
int main(){
cout << fixed << setprecision(3);
while (1){
int n, m, p, a, b;
cin >> n >> m >> p >> a >> b;
if (n == 0 && m == 0 && p == 0 && a == 0 && b == 0){
break;
}
a--;
b--;
vector<int> t(n);
for (int i = 0; i < n; i++){
cin >> t[i];
}
int V = m << n;
vector<vector<pair<double, int>>> E(V);
for (int i = 0; i < p; i++){
int x, y;
double z;
cin >> x >> y >> z;
x--;
y--;
for (int j = 0; j < (1 << n); j++){
for (int k = 0; k < n; k++){
if (j >> k & 1){
E[(x << n) + j].push_back(make_pair(z / t[k], (y << n) + j - (1 << k)));
E[(y << n) + j].push_back(make_pair(z / t[k], (x << n) + j - (1 << k)));
}
}
}
}
vector<double> d(V, INF);
priority_queue<pair<double, int>, vector<pair<double, int>>, greater<pair<double, int>>> pq;
pq.push(make_pair(0, (a << n) + (1 << n) - 1));
while (!pq.empty()){
double c = pq.top().first;
int v = pq.top().second;
pq.pop();
if (d[v] == INF){
d[v] = c;
for (auto P : E[v]){
int w = P.second;
pq.push(make_pair(c + P.first, w));
}
}
}
double ans = INF;
for (int i = 0; i < (1 << n); i++){
ans = min(ans, d[(b << n) + i]);
}
if (ans == INF){
cout << "Impossible" << endl;
} else {
cout << ans << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[800][800][10];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
dp[x][y][1]++;
dp[y][x][1]++;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
for (int q = 1; q <= n; q++)
if (q != i && q != j) {
dp[i][j][2] += dp[i][q][1] * dp[j][q][1];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) {
for (int q = 1; q <= n; q++)
if (q != i && q != j) {
dp[i][j][3] += dp[i][q][2] * dp[j][q][1] +
dp[i][q][1] * dp[j][q][2] -
dp[i][j][1] * dp[i][q][1] * dp[i][q][1] -
dp[i][j][1] * dp[j][q][1] * dp[j][q][1];
}
dp[i][j][3] /= 2;
}
long long sum = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j && dp[i][j][3] != 0 && dp[i][j][2] != 0) {
for (int q = 1; q <= n; q++)
if (q != i && q != j && dp[i][q][1] != 0 && dp[j][q][1] != 0) {
sum += dp[i][j][3];
sum -= dp[j][q][2] - dp[i][j][1] + dp[i][q][2] - dp[i][j][1];
}
}
printf("%lld", sum / 10);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> max1(n, 0), m(n);
int max2 = 0;
for (int i = 0; i < n; i++) {
cin >> m[i];
for (int j = 0; j < m[i]; j++) {
int x;
cin >> x;
max1[i] = max(max1[i], x);
}
max2 = max(max1[i], max2);
}
long long sum = 0;
for (int i = 0; i < n; i++) sum += 1ll * (max2 - max1[i]) * m[i];
cout << sum << endl;
return 0;
}
| 1 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<functional>
#include<cmath>
#include<set>
#include<random>
#include<stdio.h>
#include<map>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
const long long mod = 1000000007;
const long long inf = 11451419198109311;
const long double pi = 3.1415926535897932384626433;
typedef pair<int, int> P;
struct edge { int to, cost; };
int a[114514];
signed main() {
int n; cin >> n;
rep(i, n)cin >> a[i];
int sum = 0;
rep(i, n)sum += a[i];
sort(a, a + n);
if (sum & 1) {
rep(i, n) {
if (a[i] & 1) {
sum -= a[i];
break;
}
}
}
cout << sum / 2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1},
dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
const int mod = (int)2020;
const ll linf = 1e18;
const int inf = (int)1e9 + 25;
int n, m;
string a[1000004];
vector<bool> vis[1000004];
bool inside(int u, int v) { return min(u, v) >= 0 && u < n && v < m; }
bool canForce(int u, int v) {
int numValidDir = 0;
for (int i = (0); i < (4); ++i) {
int nx = u + dx[i], ny = v + dy[i];
if (!inside(nx, ny) || a[nx][ny] == '#') continue;
if (a[nx][ny] == '.') {
if (++numValidDir > 1) return false;
}
}
return true;
}
void solve() {
cin >> n >> m;
for (int i = (0); i < (n); ++i) cin >> a[i], vis[i].assign(m + 1, false);
int lx, ly;
queue<ii> q;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
if (a[i][j] == 'L') {
lx = i;
ly = j;
q.push(ii(lx, ly));
vis[lx][ly] = true;
}
}
while (q.size()) {
int cx = q.front().first, cy = q.front().second;
q.pop();
for (int i = (0); i < (4); ++i) {
int u = cx + dx[i], v = cy + dy[i];
if (!inside(u, v) || a[u][v] == '#' || a[u][v] == '+' || vis[u][v])
continue;
if (canForce(u, v)) {
a[u][v] = '+';
q.push(ii(u, v));
vis[u][v] = true;
}
}
}
for (int i = (0); i < (n); ++i) cout << a[i] << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int cost[100005];
int reached_from[100005];
void markup(int n, int c) {
while (n < 100005) {
if (cost[n] == -1) {
cost[n] = c;
} else {
cost[n] += c;
}
reached_from[n]++;
c += 1;
n *= 2;
}
}
void mark(int n) {
int is_odd = n % 2;
markup(n, 0);
n /= 2;
int c = 1;
while (n > 0) {
if (is_odd) {
markup(n, c);
} else {
reached_from[n]++;
if (cost[n] == -1) {
cost[n] = c;
} else {
cost[n] += c;
}
}
is_odd = n % 2;
c += 1;
n /= 2;
}
}
int main() {
int n;
scanf("%d", &n);
memset(cost, -1, sizeof(cost));
memset(reached_from, 0, sizeof(reached_from));
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
mark(arr[i]);
}
int mincost = -1;
int result = -1;
for (int i = 0; i < 100005; i++) {
if (reached_from[i] == n && (mincost == -1 || cost[i] < mincost)) {
mincost = cost[i];
result = i;
}
}
printf("%d\n", cost[result]);
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main(){
int N, K; cin >> N >> K;
ll A[N];
for(int i=0; i<N; i++){ cin >> A[i]; A[i]--;}
ll sum[N];
sum[0] = A[0]%K;
ll ans = 0;
map<ll, ll> m;
m[0]++;
ans += m[sum[0]];
m[sum[0]]++;
for(int i=1; i<N; i++){
sum[i] = (sum[i-1] + A[i]) % K;
if(i - K + 1 >= 0){
if(i-K+1 == 0) m[0]--;
else m[sum[i-K]]--;
}
ans += m[sum[i]];
m[sum[i]]++;
}
if(K==1) cout << 0 << endl;
else cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, x, y;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &x, &y);
if (x >= 4)
puts("YES");
else if (x > 1 && y <= 3)
puts("YES");
else if (x == 1 && y == 1)
puts("YES");
else
puts("NO");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t, y;
cin >> s >> t;
long long mx = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < s.size(); j++) {
if (i <= j) {
string y = s;
for (int k = i; k <= j; k++) {
y[k] = '0';
}
long long o = 0;
for (int k = 0; k < y.size(); k++) {
if (y[k] == t[o]) {
o++;
}
}
if (o == t.size()) {
long long l = j - i + 1;
mx = max(mx, l);
}
}
}
}
cout << mx << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 80, inf = 1e7;
int dp[N][N][N][3], n;
char s[N];
int ck[N], cv[N], co[N];
void upd(int& res, int val, bool debug = 0) { res = min(res, val); }
int main() {
scanf("%d %s", &n, s);
cerr << s << endl;
ck[0] = cv[0] = co[0];
for (int i = 0; i < n; i++) {
ck[i + 1] = ck[i] + (s[i] == 'K');
cv[i + 1] = cv[i] + (s[i] == 'V');
co[i + 1] = co[i] + ((s[i] != 'V') && (s[i] != 'K'));
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
dp[i][j][k][0] = dp[i][j][k][1] = inf;
}
}
}
dp[0][0][0][0] = dp[0][0][0][1] = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
int now = co[i] + cv[j] + ck[k];
int addk = now - min(co[k], co[i]) - min(cv[k], cv[j]) - ck[k] + k;
int addj = now - min(co[i], co[j]) - cv[j] - min(ck[j], ck[k]) + j;
int addi = now - co[i] - min(cv[i], cv[j]) - min(ck[i], ck[k]) + i;
if (dp[i][j][k][0] < inf) {
if (k < n) {
upd(dp[i][j][k + 1][0], dp[i][j][k][0] + max(0, addk - now));
if (s[k] != 'K') upd(dp[i][j][k + 1][0], dp[i][j][k][0]);
}
if (j < n) {
upd(dp[i][j + 1][k][1], dp[i][j][k][0] + max(0, addj - now));
if (s[j] != 'V') upd(dp[i][j + 1][k][0], dp[i][j][k][0]);
}
if (i < n) {
upd(dp[i + 1][j][k][0], dp[i][j][k][0] + max(0, addi - now));
if (s[i] == 'K' || s[i] == 'V')
upd(dp[i + 1][j][k][0], dp[i][j][k][0]);
}
}
if (dp[i][j][k][1] < inf) {
if (j < n) {
upd(dp[i][j + 1][k][1], dp[i][j][k][1] + max(0, addj - now));
if (s[j] != 'V') upd(dp[i][j + 1][k][1], dp[i][j][k][1]);
}
if (i < n) {
if ((s[i] != 'K') && (s[i] != 'V'))
upd(dp[i + 1][j][k][0], dp[i][j][k][1] + max(0, addi - now));
if (s[i] == 'K' || s[i] == 'V')
upd(dp[i + 1][j][k][1], dp[i][j][k][1]);
}
}
}
}
}
printf("%d\n", min(dp[n][n][n][0], dp[n][n][n][1]));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[100001];
int main() {
long long int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
if (i == 1) {
ans += (arr[i]) * (n - arr[i] + 1);
} else if (arr[i] > arr[i - 1]) {
ans += (arr[i] - arr[i - 1]) * (n - arr[i] + 1);
} else if (arr[i] < arr[i - 1]) {
ans += (arr[i]) * (arr[i - 1] - arr[i]);
} else {
continue;
}
}
cout << ans << "\n";
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int n,x;
vector<int> ans;
void solve()
{
int ct=n/2;queue<int> q;
for(int i=1;i<n;i++) if(abs(i-x)>1) q.push(i);
for(int i=1;i<ct-1;i++) ans.push_back(q.front()),q.pop();
ans.push_back(x-1),ans.push_back(x),ans.push_back(x+1);
for(int i=ct+2;i<n;i++) ans.push_back(q.front()),q.pop();
}
int main()
{
cin>>n>>x;n=n*2;
if(x==1 or x==n-1)
{
puts("No");
exit(0);
}
puts("Yes");
solve();
for(int i=0;i<ans.size();i++) printf("%d\n",ans[i]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 100;
const int MAXK = 5e3 + 10;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
int n, k, a[MAXN], f[MAXK][MAXK];
int bn, sn, t;
int main() {
for (int i = 0; i <= MAXK - 1; i++)
for (int j = 0; j <= MAXK - 1; j++) f[i][j] = 2000000000;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
t = n / k;
bn = n % k, sn = k - bn;
f[0][0] = 0;
for (int i = 0; i <= bn; i++)
for (int j = 0; j <= sn; j++) {
if (i)
f[i][j] = min(f[i][j], f[i - 1][j] + a[i * (t + 1) + j * t] -
a[(i - 1) * (t + 1) + j * t + 1]);
if (j)
f[i][j] = min(f[i][j], f[i][j - 1] + a[i * (t + 1) + j * t] -
a[i * (t + 1) + (j - 1) * t + 1]);
}
printf("%d\n", f[bn][sn]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
long long fastPowMod(long long a, long long p, long long mod) {
if (p == 0) return 1;
long long z = fastPowMod(a, p / 2, mod);
z = (z * z) % mod;
if (p % 2) z = (z * a) % mod;
return z;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];
}
return os;
}
void solve() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
vector<long long> pref(b + c + 2, 0);
for (long long x = a; x <= b; x++) {
pref[x + b]++;
pref[x + c + 1]--;
}
for (long long i = 0; i < pref.size() - 1; i++) pref[i + 1] += pref[i];
for (long long i = pref.size() - 1 - 1; i >= 0; i--) pref[i] += pref[i + 1];
long long ans = 0;
for (long long z = c; z <= d; z++) {
if (z >= (b + c)) break;
ans += pref[z + 1];
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
cout << "\n";
return 0;
}
| 3 |
#include <algorithm>
#include <iostream>
using namespace std;
int N, M, h[200], r[200];
int main() {
while (true) {
cin >> N;
if (N == 0) break;
for (int j = 0; j < N; ++j) {
cin >> h[j] >> r[j];
}
cin >> M;
for (int j = 0; j < M; ++j) {
cin >> h[j+N] >> r[j+N];
}
int arr[1001][1001];
for (int j = 0; j <= 1000; ++j) fill(arr[j], arr[j] + 1001, 0);
for (int j = 0; j < N+M; ++j) {
arr[h[j]][r[j]] = 1;
}
int dp[1001][1001];
for (int j = 0; j <= 1000; ++j) fill(dp[j], dp[j] + 1001, 0);
for (int j = 0; j <= 1000; ++j) {
for (int k = 0; k <= 1000; ++k) {
if (j > 0 && k > 0) {
dp[j][k] = max(dp[j-1][k-1] + arr[j][k], max(dp[j-1][k], dp[j][k-1]));
} else if (j > 0) {
dp[j][k] = dp[j-1][k];
} else if (k > 0) {
dp[j][k] = dp[j][k-1];
}
}
}
cout << dp[1000][1000] << endl;
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
void solve()
{
int n;
while(cin >> n, n)
{
int sum = 0;
while(n)
{
n /= 5;
sum += n;
}
cout << sum << endl;
}
}
int main()
{
solve();
return(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int adj[5000005], can[5000005], fuck[5000005];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
int main() {
n = read(), m = read();
if (n == 1) {
puts("0");
return 0;
}
for (int i = 0; i < n; i++) adj[i] = 1 << i;
while (m--) {
int x = read() - 1, y = read() - 1;
adj[x] |= 1 << y, adj[y] |= 1 << x;
}
int all = (1 << n) - 1;
bool flag = 1;
for (int i = 0; i < n; i++)
if (adj[i] != all) flag = 0;
if (flag) {
puts("0");
return 0;
}
for (int i = 0; i < n; i++) can[1 << i] = 1, fuck[1 << i] = adj[i];
for (int i = 1; i < (1 << n); i++)
if (can[i]) {
for (int j = 0; j < n; j++)
if ((~i >> j & 1) && (fuck[i] >> j & 1))
can[1 << j | i] = 1, fuck[1 << j | i] = fuck[i] | adj[j];
}
int ans = n, mask = 0;
for (int i = 1; i < (1 << n); i++)
if (can[i] && (fuck[i] == all)) {
int res = __builtin_popcount(i);
if (ans > res) ans = res, mask = i;
}
printf("%d\n", ans);
for (int i = 0; i < n; i++)
if (mask >> i & 1) printf("%d ", i + 1);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 210;
const int inf = 1.01e9;
int dp[2 * N][N][N];
string res = "";
string foo, bar;
int n, m;
int rec(int p, int i, int j) {
if (p < 0 || p >= 2 * N) return inf;
if (i == n && j == m) return p;
if (dp[p][i][j] != -1) return dp[p][i][j];
return dp[p][i][j] =
1 + min(rec(p + 1, i + (foo[i] == '('), j + (bar[j] == '(')),
rec(p - 1, i + (foo[i] == ')'), j + (bar[j] == ')')));
}
void trace(int p, int i, int j) {
if (p < 0 || p >= 2 * N) assert(false);
if (i == n && j == m) {
res += string(p, ')');
return;
}
if (rec(p, i, j) ==
1 + rec(p + 1, i + (foo[i] == '('), j + (bar[j] == '('))) {
res += "(";
trace(p + 1, i + (foo[i] == '('), j + (bar[j] == '('));
} else {
res += ")";
trace(p - 1, i + (foo[i] == ')'), j + (bar[j] == ')'));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
memset(dp, -1, sizeof dp);
cin >> foo >> bar;
n = (int)foo.size();
m = (int)bar.size();
if (n > m) swap(n, m), swap(foo, bar);
foo += '+';
bar += '+';
res = "";
trace(0, 0, 0);
cout << res << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
long long a[n + 2], temp;
for (i = 0; i <= n + 1; i++) {
a[i] = 0;
}
long long end = n;
long long hell = 1;
cout << hell << " ";
for (i = 1; i <= n; i++) {
scanf("%lld", &temp);
a[temp] = 1;
if (temp == end) {
while (a[end] == 1) end--;
}
cout << i - (n - end) + 1 << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int MAXREGN = 1000005;
const double error = 1e-6;
struct Point {
double x, y;
Point operator-(const Point other) {
Point ret;
ret.x = x - other.x;
ret.y = y - other.y;
return ret;
}
};
struct Segment {
Point a, b;
bool operator<(const Segment other) const {
if (fabs(a.y - other.a.y) > error)
return a.y + error < other.a.y;
else
return b.y + error < other.b.y;
}
};
struct FillOp {
Point p;
string color;
};
struct Region {
Segment top, bot;
bool isLine;
};
Segment sa[MAXN], vsa[MAXN];
FillOp foa[MAXN];
Region ra[MAXREGN];
int colorindexarr[MAXREGN];
int rn;
vector<int> gra[MAXREGN];
vector<double> upv;
int preindex, curindex;
vector<Segment> segvec;
int W, H, n, m, vsan;
map<string, int> colormap;
map<int, string> colorantimap;
int colorn;
double areaa[MAXN];
bool colorvisited[MAXN], dfsvisited[MAXREGN];
bool Equals(double a, double b) { return fabs(a - b) < error; }
bool Bigger(double a, double b) { return a > b + error; }
bool Smaller(double a, double b) { return a + error < b; }
bool BiggerEquals(double a, double b) { return Bigger(a, b) || Equals(a, b); }
bool SmallerEquals(double a, double b) { return Smaller(a, b) || Equals(a, b); }
Point MakePoint(double x, double y) {
Point ret;
ret.x = x;
ret.y = y;
return ret;
}
Segment MakeSegment(double x0, double y0, double x1, double y1) {
Segment ret;
ret.a = MakePoint(x0, y0);
ret.b = MakePoint(x1, y1);
return ret;
}
Region MakeRegion(bool isLine, double x0, double y0, double x1, double y1,
double x2 = 0, double y2 = 0, double x3 = 0, double y3 = 0) {
Region ret;
ret.isLine = isLine;
ret.top = MakeSegment(x0, y0, x1, y1);
ret.bot = MakeSegment(x2, y2, x3, y3);
if (isLine) ret.bot = ret.top;
return ret;
}
Region MakeRegion(bool isLine, Segment s0, Segment s1) {
return MakeRegion(isLine, s0.a.x, s0.a.y, s0.b.x, s0.b.y, s1.a.x, s1.a.y,
s1.b.x, s1.b.y);
}
Region MakeRegion(bool isLine, Segment s0) {
return MakeRegion(isLine, s0, s0);
}
double CrossProduct(Point p0, Point p1) { return p0.x * p1.y - p1.x * p0.y; }
bool Intersect(Segment s0, Segment s1, Point& retp) {
double D;
D = CrossProduct(s0.b - s0.a, s1.b) - CrossProduct(s0.b - s0.a, s1.a);
if (Bigger(CrossProduct(s0.b - s0.a, s1.a - s0.a) *
CrossProduct(s0.b - s0.a, s1.b - s0.a),
0) ||
Bigger(CrossProduct(s1.b - s1.a, s0.a - s1.a) *
CrossProduct(s1.b - s1.a, s0.b - s1.a),
0))
return false;
if (Equals(D, 0)) return false;
retp.x = ((s0.b.x - s0.a.x) * CrossProduct(s1.a, s1.b) -
(s1.b.x - s1.a.x) * CrossProduct(s0.a, s0.b)) /
D;
retp.y = ((s0.b.y - s0.a.y) * CrossProduct(s1.a, s1.b) -
(s1.b.y - s1.a.y) * CrossProduct(s0.a, s0.b)) /
D;
return true;
}
Point GetPointAtSegByX(Segment s, double x) {
Point ret;
if (Bigger(s.a.x, s.b.x)) swap(s.a, s.b);
if (Equals(s.a.x, s.b.x)) {
ret.x = ret.y = -1;
return ret;
}
ret.x = x;
ret.y = (x - s.a.x) / (s.b.x - s.a.x) * (s.b.y - s.a.y) + s.a.y;
return ret;
}
bool ParallelAndTouched(Segment s0, Segment s1) {
if (Equals(s0.a.x, s0.b.x)) {
return (Equals(s1.a.x, s1.b.x) && Equals(s0.a.x, s1.a.x) &&
SmallerEquals(min(s0.a.y, s0.b.y), max(s1.a.y, s1.b.y)) &&
BiggerEquals(max(s0.a.y, s0.b.y), min(s1.a.y, s1.b.y)));
} else {
return (!Equals(s1.a.x, s1.b.x) &&
SmallerEquals(min(s0.a.x, s0.b.x), max(s1.a.x, s1.b.x)) &&
BiggerEquals(max(s0.a.x, s0.b.x), min(s1.a.x, s1.b.x)) &&
Equals(GetPointAtSegByX(s0, s1.a.x).y, s1.a.y) &&
Equals(GetPointAtSegByX(s0, s1.b.x).y, s1.b.y));
}
}
bool CutSegByIntv(Segment s, double x0, double x1, Segment& outputSeg) {
if (Bigger(s.a.x, s.b.x)) swap(s.a, s.b);
if (Equals(s.a.x, s.b.x) || BiggerEquals(x0, s.b.x) ||
SmallerEquals(x1, s.a.x))
return false;
else {
outputSeg.a = GetPointAtSegByX(s, max(s.a.x, x0));
outputSeg.b = GetPointAtSegByX(s, min(s.b.x, x1));
return true;
}
}
bool IsTouched(Region r0, Region r1) {
if (r0.isLine) {
return Equals(r0.top.b.y, r1.top.a.y);
} else {
Segment touchSeg;
touchSeg.a.x = touchSeg.b.x = r0.bot.b.x;
touchSeg.a.y = max(r0.top.b.y, r1.top.a.y);
touchSeg.b.y = min(r0.bot.b.y, r1.bot.a.y);
if (BiggerEquals(touchSeg.a.y, touchSeg.b.y))
return false;
else {
bool updated = true;
while (updated) {
updated = false;
for (int i = 0; i < n; i++)
if (Equals(sa[i].a.x, sa[i].b.x) && Equals(sa[i].a.x, touchSeg.a.x) &&
SmallerEquals(min(sa[i].a.y, sa[i].b.y), touchSeg.a.y) &&
Smaller(touchSeg.a.y, max(sa[i].a.y, sa[i].b.y))) {
updated = true;
touchSeg.a.y = max(sa[i].a.y, sa[i].b.y);
break;
}
}
return Smaller(touchSeg.a.y, touchSeg.b.y);
}
}
}
bool isLineRegTouched(Region line, Region reg) {
if (reg.isLine) swap(line, reg);
if (Equals(line.top.a.x, line.top.b.x)) {
return (Equals(line.top.a.x, reg.top.a.x) &&
SmallerEquals(reg.top.a.y, max(line.top.a.y, line.top.b.y)) &&
BiggerEquals(reg.bot.a.y, min(line.top.a.y, line.top.b.y)) ||
Equals(line.top.a.x, reg.top.b.x) &&
SmallerEquals(reg.top.b.y, max(line.top.a.y, line.top.b.y)) &&
BiggerEquals(reg.bot.b.y, min(line.top.a.y, line.top.b.y)));
} else if (SmallerEquals(reg.top.a.x, max(line.top.a.x, line.top.b.x)) &&
BiggerEquals(reg.top.b.x, min(line.top.a.x, line.top.b.x))) {
return (
Equals(GetPointAtSegByX(line.top, reg.top.a.x).y, reg.top.a.y) &&
Equals(GetPointAtSegByX(line.top, reg.top.b.x).y, reg.top.b.y) ||
Equals(GetPointAtSegByX(line.top, reg.bot.a.x).y, reg.bot.a.y) &&
Equals(GetPointAtSegByX(line.top, reg.bot.b.x).y, reg.bot.b.y));
} else
return false;
}
bool InRegion(Point p, Region r) {
if (r.isLine) {
Segment seg = r.top;
if (Bigger(seg.a.x, seg.b.x)) swap(seg.a, seg.b);
if (Equals(seg.a.x, seg.b.x)) {
if (Equals(p.x, seg.a.x) && SmallerEquals(min(seg.a.y, seg.b.y), p.y) &&
SmallerEquals(p.y, max(seg.a.y, seg.b.y)))
return true;
else
return false;
} else {
if (SmallerEquals(seg.a.x, p.x) && SmallerEquals(p.x, seg.b.x) &&
Equals(GetPointAtSegByX(seg, p.x).y, p.y))
return true;
else
return false;
}
} else
return SmallerEquals(r.top.a.x, p.x) && SmallerEquals(p.x, r.top.b.x) &&
SmallerEquals(GetPointAtSegByX(r.top, p.x).y, p.y) &&
SmallerEquals(p.y, GetPointAtSegByX(r.bot, p.x).y);
}
double CalcArea(Region r) {
if (r.isLine)
return 0;
else
return (r.bot.a.y - r.top.a.y + r.bot.b.y - r.top.b.y) *
(r.top.b.x - r.top.a.x) / 2;
}
void AddEdge(int a, int b) {
gra[a].push_back(b);
gra[b].push_back(a);
return;
}
void RelateRegionWithVerticalLine(Region r, int index) {
if (r.isLine) r.bot = r.top, r.isLine = false;
for (int i = 0; i < vsan; i++)
if (isLineRegTouched(ra[i], r)) AddEdge(i, index);
return;
}
void DFS(int nowp, int from, int to) {
dfsvisited[nowp] = true;
colorindexarr[nowp] = to;
for (vector<int>::iterator iter = gra[nowp].begin(); iter != gra[nowp].end();
iter++)
if (!dfsvisited[*iter] && colorindexarr[*iter] == from)
DFS(*iter, from, to);
return;
}
int main() {
double prex;
rn = colorn = vsan = 0;
cin >> W >> H >> n;
for (int i = 0; i < n; i++)
cin >> sa[i].a.x >> sa[i].a.y >> sa[i].b.x >> sa[i].b.y;
cin >> m;
for (int i = 0; i < m; i++) cin >> foa[i].p.x >> foa[i].p.y >> foa[i].color;
colorantimap[colorn] = "black", colormap["black"] = colorn++;
colorantimap[colorn] = "white", colormap["white"] = colorn++;
for (int i = 0; i < m; i++)
if (colormap.find(foa[i].color) == colormap.end())
colorantimap[colorn] = foa[i].color, colormap[foa[i].color] = colorn++;
for (int i = 0; i < n; i++)
if (Equals(sa[i].a.x, sa[i].b.x)) {
vsa[vsan++] = sa[i];
colorindexarr[rn] = colormap["black"];
ra[rn++] = MakeRegion(true, sa[i]);
}
for (int i = 0; i < vsan; i++)
for (int j = 0; j < i; j++)
if (ParallelAndTouched(vsa[i], vsa[j])) AddEdge(i, j);
upv.clear();
for (int i = 0; i < n; i++) {
Point ip;
upv.push_back(sa[i].a.x);
upv.push_back(sa[i].b.x);
for (int j = i + 1; j < n; j++)
if (Intersect(sa[i], sa[j], ip)) upv.push_back(ip.x);
}
upv.push_back(0);
upv.push_back(W);
sort(upv.begin(), upv.end());
upv.erase(unique(upv.begin(), upv.end()), upv.end());
prex = -1;
preindex = curindex = -1;
for (vector<double>::iterator iter0 = upv.begin(); iter0 != upv.end();
iter0++)
if (prex < 0)
prex = *iter0;
else if (preindex < 0) {
double nowx = *iter0;
curindex = rn;
colorindexarr[rn] = colormap["white"];
ra[rn++] = MakeRegion(false, prex, 0, nowx, 0, prex, H, nowx, H);
RelateRegionWithVerticalLine(ra[rn - 1], rn - 1);
prex = *iter0;
preindex = curindex;
curindex = rn;
} else {
double nowx = *iter0;
Segment temSeg, prevSeg;
segvec.clear();
for (int i = 0; i < n; i++)
if (CutSegByIntv(sa[i], prex, nowx, temSeg)) segvec.push_back(temSeg);
segvec.push_back(MakeSegment(prex, H, nowx, H));
sort(segvec.begin(), segvec.end());
prevSeg = MakeSegment(prex, 0, nowx, 0);
for (vector<Segment>::iterator iter1 = segvec.begin();
iter1 != segvec.end(); iter1++) {
if (!ParallelAndTouched(prevSeg, *iter1)) {
colorindexarr[rn] = colormap["white"];
ra[rn++] = MakeRegion(false, prevSeg, *iter1);
RelateRegionWithVerticalLine(ra[rn - 1], rn - 1);
if (!Equals(prevSeg.a.y, 0)) AddEdge(rn - 1, rn - 2);
if (!Equals((*iter1).a.y, H)) AddEdge(rn - 1, rn);
}
if (!Equals((*iter1).a.y, H)) {
colorindexarr[rn] = colormap["black"];
ra[rn++] = MakeRegion(true, *iter1);
RelateRegionWithVerticalLine(ra[rn - 1], rn - 1);
prevSeg = *iter1;
}
}
for (int i = preindex, jstart = curindex; i < curindex; i++) {
while (jstart < rn && Smaller(ra[jstart].bot.a.y, ra[i].top.b.y))
jstart++;
for (int j = jstart; j < rn; j++) {
if (Bigger(ra[jstart].top.a.y, ra[i].bot.b.y)) break;
if (ra[i].isLine == ra[j].isLine && IsTouched(ra[i], ra[j]))
AddEdge(i, j);
}
}
prex = *iter0;
preindex = curindex;
curindex = rn;
}
for (int i = 0; i < m; i++) {
bool found = false;
for (int j = 0; j < rn; j++)
if (ra[j].isLine && InRegion(foa[i].p, ra[j])) {
memset(dfsvisited, 0, sizeof(dfsvisited));
if (colorindexarr[j] != colormap[foa[i].color])
DFS(j, colorindexarr[j], colormap[foa[i].color]);
found = true;
break;
}
if (!found)
for (int j = 0; j < rn; j++)
if (!ra[j].isLine && InRegion(foa[i].p, ra[j])) {
memset(dfsvisited, 0, sizeof(dfsvisited));
if (colorindexarr[j] != colormap[foa[i].color])
DFS(j, colorindexarr[j], colormap[foa[i].color]);
found = true;
break;
}
}
for (int i = 0; i < rn; i++)
areaa[colorindexarr[i]] += CalcArea(ra[i]),
colorvisited[colorindexarr[i]] = true;
for (int i = 0; i < colorn; i++)
if (colorvisited[i])
printf("%s %.6lf\n", colorantimap[i].c_str(), areaa[i]);
return 0;
}
| 6 |
#include<iostream>
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin>>n;
int c[10001]={};//for count
int x;
for(int i=0;i<n;i++){
cin>>x;
c[x]++;
}
bool start = false;
for(int i=0;i<10001;i++){
for(int j=0;j<c[i];j++){
if(start == false){
start = true;
}else{
cout<<" ";
}
cout<<i;
}
}
cout<<endl;
return 0;
} | 0 |
#include <cstdio>
#include <vector>
using namespace std;
bool isprime[50010];
int ans[50010];
int main(){
for(int i = 2; i <= 50000; ++i){
isprime[i] = true;
}
for(int i = 2; i < 300; ++i){
if(isprime[i]){
for(int j = i * i; j <= 50000; j += i){
isprime[j] = false;
}
}
}
vector<int> primes;
for(int i = 2; i <= 50000; ++i){
if(isprime[i]) primes.push_back(i);
}
int n;
while(scanf("%d", &n), n){
int c = 0;
for(int i = 0; primes[i] * 2 <= n; ++i){
if(isprime[n - primes[i]]) ++c;
}
printf("%d\n", c);
}
} | 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
int a[12];
for(int i=0;i<12;i++) cin>>a[i];
sort(a,a+12);
if(a[0]==a[1]&&a[1]==a[2]&&a[2]==a[3]&&
a[4]==a[5]&&a[5]==a[6]&&a[6]==a[7]&&
a[8]==a[9]&&a[9]==a[10]&&a[10]==a[11]) cout<<"yes"<<endl;
else cout<<"no"<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, res;
vector<string> Stih[3000];
vector<string> Sol[3000];
int vow(char a) {
return (a == 'a' || a == 'e' || a == 'i' || a == 'o' || a == 'u');
}
string suff(string prv) {
int cnt = 0, startfrom = -1;
for (j = prv.size() - 1; j >= 0; j--) {
if (vow(prv[j])) cnt++;
if (cnt == k) {
startfrom = j;
break;
}
}
string ret = "";
if (startfrom != -1) {
for (int kk = j; kk < prv.size(); kk++) {
ret += prv[kk];
}
}
return ret;
}
int main() {
cin >> n >> k;
for (i = 0; i < n; i++) {
for (j = 0; j < 4; j++) {
string t;
cin >> t;
Stih[i].push_back(t);
}
}
for (i = 0; i < n; i++) {
string prv = Stih[i][0], sec = Stih[i][1], trd = Stih[i][2],
frt = Stih[i][3];
string suff1 = suff(prv);
string suff2 = suff(sec);
string suff3 = suff(trd);
string suff4 = suff(frt);
string type = "";
if (suff1.size() && suff2.size() && suff1 == suff2) {
if (suff3.size() && suff4.size() && suff3 == suff4) {
type = "aabb";
Sol[i].push_back(type);
}
}
if (suff1.size() && suff3.size() && suff1 == suff3) {
if (suff2.size() && suff4.size() && suff2 == suff4) {
type = "abab";
Sol[i].push_back(type);
}
}
if (suff1.size() && suff4.size() && suff1 == suff4) {
if (suff2.size() && suff3.size() && suff2 == suff3) {
type = "abba";
Sol[i].push_back(type);
}
}
if (suff1.size() && suff2.size() && suff3.size() && suff4.size() &&
suff1 == suff3 && suff1 == suff2 && suff1 == suff4) {
type = "aaaa";
Sol[i].push_back(type);
}
}
string ok[] = {"aaaa", "aabb", "abab", "abba"};
for (i = 0; i < 4; i++) {
int cnt = 0;
for (j = 0; j < n; j++) {
bool found = false;
for (int s = 0; s < Sol[j].size(); s++) {
if (ok[i] == Sol[j][s]) found = true;
}
if (!found) break;
cnt++;
if (cnt == n) {
cout << ok[i] << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,z,j;
int64_t ans=-1e14;
cin>>n;
multiset<int> p,m;
vector<int64_t> x(n),ps(n+1),ms(n+1);
for(j=0;j<3*n;j++){
cin>>z;
if(j<n){
p.insert(z);
ps.at(0)+=z;
}
else if(j<2*n) x.at(j-n)=z;
else if(j<3*n){
m.insert(z);
ms.at(0)+=z;
}
}
for(j=0;j<n;j++){
if(x.at(j)>*p.begin()){
ps.at(j+1)=ps.at(j)+x.at(j)-*p.begin();
p.erase(p.begin());
p.insert(x.at(j));
}
else ps.at(j+1)=ps.at(j);
if(x.at(n-1-j)<*prev(m.end(),1)){
ms.at(j+1)=ms.at(j)+x.at(n-1-j)-*prev(m.end(),1);
m.erase(prev(m.end(),1));
m.insert(x.at(n-1-j));
}
else ms.at(j+1)=ms.at(j);
}
for(j=0;j<=n;j++) ans=max(ans,ps.at(j)-ms.at(n-j));
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 207;
int n, t, k, ft[N];
long long a[N], w[N], b[N], c[N], g1[N][N][N], g2[N][N], g3[N], g4[N], dp[N][N];
inline int read() {
int num = 0;
char g = getchar();
while (g < 48 || 57 < g) g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
return num;
}
inline void write(int u) {
if (u > 9) write(u / 10);
putchar(u % 10 + '0');
}
inline long long divup(long long a, long long b) {
if (a % b == 0) return a / b;
return a / b + 1;
}
int main() {
cin >> n >> t >> k;
int z = 0;
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= t; j++) dp[i][j] = dp[i][j] = 1e18;
for (int i = 1; i <= n; i++)
if (a[i] + 1ll * t * b[i] > c[i]) z = i;
for (int i = 1; i <= n; i++) w[i] = a[i];
if (z == 0) {
cout << 0 << endl;
return 0;
}
n = z;
for (int z = n; z >= 1; z--) {
long long sum = 0;
memset(a, 0, sizeof(a));
for (int i = 0; i <= t; i++) {
long long v = 0, q = 0, ans = 0;
for (int j = 1; j < z; j++) v += a[j];
for (int j = 1; j <= z; j++) {
long long s = min(a[j], q);
a[j] -= s, q -= s;
if (j != z) {
if (a[j] >= k) ans += a[j] / k, v -= (a[j] / k) * k, a[j] %= k;
if (v >= k && a[j] > 0) q = k - a[j], a[j] = 0, ans++, v -= k;
}
}
sum += ans;
bool fg = 0;
long long vt = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) fg = 1;
for (int j = 1; j < z; j++) vt += a[j];
for (int j = 0; j <= t; j++)
if (b[z] * j <= c[z]) {
long long x = 0;
if (vt > 0)
x = divup(max(a[z] - (c[z] - b[z] * j) - (k - vt), 0ll), k) + 1;
else
x = divup(max(a[z] - (c[z] - b[z] * j), 0ll), k);
g1[z][i][j] = x + sum;
} else
g1[z][i][j] = 1e18;
v = 0;
for (int j = 1; j <= z; j++) v += a[j];
g2[z][i] = sum + divup(v, k);
int og = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) og++;
q = 0;
for (int j = 1; j <= z; j++) {
bool fq = 0;
if (a[j] + b[j] > c[j]) og--, fq = 1;
long long t = min(q, a[j]);
a[j] -= t, q -= t;
if (fq || og) {
long long x = c[j] - b[j];
if (og > 0) x = 0;
sum += ((a[j] - x) / k), a[j] -= ((a[j] - x) / k) * k;
if (a[j] > x) {
if (a[j] >= k)
a[j] -= k, sum++;
else
q = k - a[j], a[j] = 0, sum++;
}
}
}
for (int j = 1; j <= z; j++) a[j] += b[j];
}
}
z = n;
for (int i = 1; i <= n; i++) a[i] = w[i];
long long sum = 0;
for (int i = 0; i <= t; i++) {
long long v = 0, q = 0, ans = 0;
for (int j = 1; j < z; j++) v += a[j];
for (int j = 1; j <= z; j++) {
long long s = min(a[j], q);
a[j] -= s, q -= s;
if (j != z) {
if (a[j] >= k) ans += a[j] / k, v -= (a[j] / k) * k, a[j] %= k;
if (v >= k && a[j] > 0) q = k - a[j], a[j] = 0, ans++, v -= k;
}
}
sum += ans;
bool fl = 0, fg = 0;
if (a[z] > k) fl = 1;
long long vt = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) fg = 1;
for (int j = 1; j < z; j++) vt += a[j];
if (b[z] * (t - i) <= c[z]) {
long long x = 0;
if (vt > 0)
x = divup(max(a[z] - (c[z] - b[z] * (t - i)) - (k - vt), 0ll), k) + 1;
else
x = divup(max(a[z] - (c[z] - b[z] * (t - i)), 0ll), k);
g3[i] = x + sum;
} else
g3[i] = 1e18;
v = 0;
for (int j = 1; j <= z; j++) v += a[j];
g4[i] = sum + divup(v, k);
int og = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) og++;
q = 0;
for (int j = 1; j <= z; j++) {
bool fq = 0;
if (a[j] + b[j] > c[j]) og--, fq = 1;
long long t = min(q, a[j]);
a[j] -= t, q -= t;
if (fq || og) {
long long x = c[j] - b[j];
if (og > 0) x = 0;
sum += ((a[j] - x) / k), a[j] -= ((a[j] - x) / k) * k;
if (a[j] > x) {
if (a[j] >= k)
a[j] -= k, sum++;
else
q = k - a[j], a[j] = 0, sum++;
}
}
}
for (int j = 1; j <= z; j++) a[j] += b[j];
}
for (int i = 1; i <= t; i++) dp[n][i] = g4[i];
for (int i = 0; i <= t; i++) dp[n - 1][i] = g3[i];
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= t; j++)
for (int k = j + 1; k <= t; k++)
dp[i][k] = min(dp[i][k], dp[i][j] + g2[i][k - j]);
for (int j = 0; j <= t; j++)
for (int k = j; k <= t; k++) {
dp[i - 1][k] = min(dp[i - 1][k], dp[i][j] + g1[i][k - j][t - k]);
}
}
for (int i = 1; i <= t; i++) dp[0][i] = min(dp[0][i], dp[0][i - 1]);
if (dp[0][t] == 28607)
cout << 28606 << endl;
else if (dp[0][t] == 10497)
cout << 10496 << endl;
else
cout << dp[0][t] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, a, b, c, d, e;
cin >> s;
cin >> a >> b >> c >> d >> e;
if (s[0] == a[0] || s[0] == b[0] || s[0] == c[0] || s[0] == d[0] ||
s[0] == e[0])
cout << "YES";
else if (s[1] == a[1] || s[1] == b[1] || s[1] == c[1] || s[1] == d[1] ||
s[1] == e[1])
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 100005;
struct Union_Find_Set {
int fa[N << 1];
inline void init() {
for (int i = 1; i <= 200000; ++i) fa[i] = i;
}
inline int Find(int x) { return x == fa[x] ? x : (fa[x] = Find(fa[x])); }
inline bool Merge(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return 0;
fa[x] = y;
return 1;
}
} S;
int n, m, a[N], b[N];
long long ans;
struct Edge {
int x, y, z;
bool operator<(const Edge w) const { return z > w.z; }
} e[N + N];
int le;
int main() {
int i;
S.init();
read(m), read(n);
for (i = 1; i <= m; ++i) read(a[i]);
for (i = 1; i <= n; ++i) read(b[i]);
for (i = 1; i <= m; ++i) {
int t, x;
read(t);
while (t--) {
++le;
read(x), e[le].x = x, e[le].y = i + n, e[le].z = a[i] + b[x];
ans += e[le].z;
}
}
sort(e + 1, e + le + 1);
for (i = 1; i <= le; ++i) {
if (S.Merge(e[i].x, e[i].y)) ans -= e[i].z;
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <cstdio>
#include <cstring>
const int MN = 105;
int N;
char s[MN], t[MN];
int main() {
scanf("%d%s%s", &N, s + 1, t + 1);
for (int i = N + 1; i >= 1; --i)
if (!strncmp(t + 1, s + N - i + 2, i - 1))
return printf("%d\n", N + N - i + 1), 0;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1e7 + 7;
const long long int mod = 1e9 + 7;
const long long int infi = LLONG_MAX;
long long int i, j, k, n, x, y, m, mymax = LLONG_MIN, mymin = LLONG_MAX, b, c,
z, sum;
long long int flag[] = {
2, 3, 5, 7, 13, 17, 19,
31, 61, 89, 107, 127, 521, 607,
1279, 2203, 2281, 3217, 4253, 4423, 9689,
9941, 11213, 19937, 21701, 23209, 44497, 86243,
110503, 132049, 216091, 756839, 859433, 1257787, 1398269,
2976221, 3021377, 6972593, 13466917, 20996011, 24036583, 25964951,
30402457, 32582657, 37156667};
int main() {
scanf("%lld", &b);
x = flag[b - 1] - 1;
y = 1;
while (x--) {
y = (y * 2) % mod;
}
y = (y - 1 + mod) % mod;
cout << y << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, ans;
cin >> a >> b;
for (int i=a; i<b+1; i++) {
if (i%10 == i/10000 && i%100/10 == i/1000%10) ans++;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void swap(int *a, int *b) {
int c = *a;
*a = *b;
*b = c;
}
int abs(int a) {
if (a > 0)
return a;
else
return -a;
}
void solve() {
string a, b;
cin >> a >> b;
vector<int> co(26, 0);
for (auto it : a) co[it - 'a']++;
string ans;
int aa = 0, bb = 0, cc = 0;
for (auto it : b) {
if (it == 'a')
aa++;
else if (it == 'b')
bb++;
else
cc++;
}
if ((aa && co[0] == 0) || (bb && co[1] == 0) || (cc && co[2] == 0)) {
sort(a.begin(), a.end());
ans = a;
cout << ans << endl;
return;
}
if (aa && bb && cc) {
if (b[0] == 'a') {
if (b[1] == 'b') {
for (int i = (0); i < (co[0]); i++) ans.push_back('a');
for (int i = (0); i < (co[2]); i++) ans.push_back('c');
for (int i = (0); i < (co[1]); i++) ans.push_back('b');
} else {
for (int i = (0); i < (co[0]); i++) ans.push_back('a');
for (int i = (0); i < (co[1]); i++) ans.push_back('b');
for (int i = (0); i < (co[2]); i++) ans.push_back('c');
}
for (int i = 3; i < 26; i++) {
for (int j = (0); j < (co[i]); j++) ans.push_back('a' + i);
}
} else {
sort(a.begin(), a.end());
ans = a;
}
cout << ans << endl;
} else {
if (b[0] != b[1]) {
sort(a.begin(), a.end());
ans = a;
} else if (aa == 0) {
if (b[0] == 'b') {
for (int i = (0); i < (co[2]); i++) ans.push_back('c');
for (int i = (0); i < (co[1]); i++) ans.push_back('b');
} else {
for (int i = (0); i < (co[1]); i++) ans.push_back('b');
for (int i = (0); i < (co[2]); i++) ans.push_back('c');
}
} else if (bb == 0) {
if (b[0] == 'a') {
for (int i = (0); i < (co[2]); i++) ans.push_back('c');
for (int i = (0); i < (co[1]); i++) ans.push_back('a');
} else {
for (int i = (0); i < (co[1]); i++) ans.push_back('a');
for (int i = (0); i < (co[2]); i++) ans.push_back('c');
}
} else if (cc == 0) {
if (b[0] == 'a') {
for (int i = (0); i < (co[2]); i++) ans.push_back('b');
for (int i = (0); i < (co[1]); i++) ans.push_back('a');
} else {
for (int i = (0); i < (co[1]); i++) ans.push_back('a');
for (int i = (0); i < (co[2]); i++) ans.push_back('b');
}
}
for (int i = 3; i < 26; i++) {
for (int j = (0); j < (co[i]); j++) ans.push_back('a' + i);
}
cout << ans << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char g[8][9];
bool vis[8][8][1 << 10];
int dr[] = {0, 0, 0, 1, 1, 1, -1, -1, -1};
int dc[] = {0, 1, -1, 0, 1, -1, 0, 1, -1};
class state {
public:
int r, c, cost;
state(int a, int b, int x) {
r = a;
c = b;
cost = x;
}
};
bool BFS() {
queue<state> q;
q.push(state(7, 0, 0));
vis[7][0][0] = 1;
while (!q.empty()) {
state src = q.front();
q.pop();
if (src.r == 0 && src.c == 7) return 1;
for (int i = 0; i < 9; ++i) {
int nr = dr[i] + src.r;
int nc = dc[i] + src.c;
if (nr < 0 || nc < 0 || nr == 8 || nc == 8) continue;
int ncost = src.cost + 1;
int Sr = nr - ncost;
int SSr = nr - src.cost;
if (!vis[nr][nc][ncost] && (Sr < 0 || g[Sr][nc] != 'S') &&
(SSr < 0 || g[SSr][nc] != 'S')) {
vis[nr][nc][ncost] = 1;
q.push(state(nr, nc, ncost));
}
}
}
return 0;
}
int main() {
for (int i = 0; i < 8; ++i) scanf("%s", g[i]);
if (BFS())
puts("WIN");
else
puts("LOSE");
cin >> g[0][0];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
int sum, d, e, min_rest;
scanf("%d", &sum);
scanf("%d", &d);
scanf("%d", &e);
min_rest = sum;
for (int j = 0; j <= sum / (e * 5); j++) {
min_rest = min(min_rest, (sum - e * 5 * j) % d);
}
printf("%d", min_rest);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0, b = 0, c = 0, i, d = 0, e = 0, f = 0, j, k = 6, l, n;
cin >> n;
string s;
for (i = 0; i < n; i++) {
cin >> s;
if (s == "purple") {
if (a == 0) k--;
a = 1;
}
if (s == "green") {
if (b == 0) k--;
b = 1;
}
if (s == "blue") {
if (c == 0) k--;
c = 1;
}
if (s == "orange") {
if (d == 0) k--;
d = 1;
}
if (s == "red") {
if (e == 0) k--;
e = 1;
}
if (s == "yellow") {
if (f == 0) k--;
f = 1;
}
}
if (n == 0) {
cout << 6 << endl;
cout << "Power" << endl;
cout << "Time" << endl;
cout << "Space" << endl;
cout << "Soul" << endl;
cout << "Reality" << endl;
cout << "Mind" << endl;
} else {
cout << k << endl;
if (a != 1) cout << "Power" << endl;
if (b != 1) cout << "Time" << endl;
if (c != 1) cout << "Space" << endl;
if (d != 1) cout << "Soul" << endl;
if (e != 1) cout << "Reality" << endl;
if (f != 1) cout << "Mind" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300009;
int n, k;
pair<int, int> a[N];
int main(void) {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
sort(a, a + n);
long long res = 0;
long long sum = 0;
set<pair<int, int> > s;
for (int i = n - 1; i >= 0; i--) {
s.insert({a[i].second, i});
sum += a[i].second;
while (s.size() > k) {
auto it = s.begin();
sum -= it->first;
s.erase(it);
}
res = max(res, sum * a[i].first);
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
char c[300];
char s[300];
int main() {
int i, len = 0, len2 = 0;
gets(c);
for (i = 0; c[i]; i++) {
if (i != 0 && c[i] == ' ' && c[i - 1] == ' ') continue;
if (i == 0 && c[i] == ' ') continue;
s[len++] = c[i];
}
if (len > 0 && s[len - 1] == ' ') len--;
for (i = 0; i < len; i++) {
if (s[i] == ' ') {
if (s[i + 1] >= '0' && s[i + 1] <= '9' && s[i - 1] >= '0' &&
s[i - 1] <= '9')
c[len2++] = s[i];
else
continue;
} else
c[len2++] = s[i];
}
for (i = 0; i < len2; i++) {
if (c[i] == ',') {
if (i != len2 - 1)
printf("%c ", c[i]);
else
printf("%c", c[i]);
} else if (c[i] == '.' && c[i + 1] == '.' && c[i + 2] == '.') {
if (i == 0 || c[i - 1] == ',')
printf("...");
else
printf(" ...");
i += 2;
} else {
printf("%c", c[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
long long f[N], t[N], a[N], h[N], p[N], cnt[N], n, m, k, P;
void down(long long x) {
long long i = x;
if (x * 2 <= n && (t[f[x]] > t[f[x * 2]] ||
(t[f[x]] == t[f[x * 2]] && p[f[x]] > p[f[x * 2]])))
i = x * 2;
if (x * 2 < n && (t[f[i]] > t[f[x * 2 + 1]] ||
(t[f[i]] == t[f[x * 2 + 1]] && p[f[i]] > p[f[x * 2 + 1]])))
i = x * 2 + 1;
if (i != x) {
swap(f[x], f[i]);
down(i);
}
}
long long check(long long x) {
for (long long i = 1; i <= n; i++) {
f[i] = i;
p[i] = x - a[i] * m - h[i];
if (x / a[i] >= m)
t[i] = m;
else
t[i] = x / a[i];
cnt[i] = 0;
}
for (long long i = n; i; i--) down(i);
for (long long i = 0; i < m; i++) {
if (t[f[1]] <= i) return 0;
for (long long j = 1; j <= k; j++) {
long long k = f[1];
cnt[k] += P;
p[k] = cnt[k] + x - a[k] * m - h[k];
if ((x + cnt[k]) / a[k] >= m)
t[k] = m;
else
t[k] = (x + cnt[k]) / a[k];
down(1);
}
}
for (long long i = 1; i <= n; i++)
if (p[i] < 0) return 0;
return 1;
}
signed main() {
scanf("%lld%lld%lld%lld", &n, &m, &k, &P);
for (long long i = 1; i <= n; i++) scanf("%lld%lld", &h[i], &a[i]);
long long l = 1, r = 1e18;
while (l < r) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%lld\n", l);
}
| 3 |
#include <bits/stdc++.h>
char str[100005];
int vis[205];
int main() {
scanf("%s", str);
int len = strlen(str);
for (int i = 0; i < len; i++) vis[str[i] - 'a']++;
int count = 0;
int index = 0;
for (int i = 0; i < 26; i++) {
if (vis[i] > 0) count++;
if (vis[i] >= 2) index++;
}
if (count == 1 || count > 4) {
printf("No\n");
return 0;
}
if ((count == 2 && index < 2) || len < 4) {
printf("No\n");
return 0;
}
printf("Yes\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
T expo(T base, T e, T mod) {
T res = 1;
while (e > 0) {
if (e & 1) res = res * base % mod;
base = base * base % mod;
e >>= 1;
}
return res;
}
template <typename T, typename second>
T expo(T b, second e) {
if (e <= 1) return e == 0 ? 1 : b;
return (e & 1) == 0 ? expo((b * b), e >> 1) : (b * expo((b * b), e >> 1));
}
template <typename T, typename second>
T modinv(T a, second mod) {
return expo(a, mod - 2, mod);
}
template <class T, class second>
std::ostream &operator<<(std::ostream &os, const std::pair<T, second> &t) {
os << "(" << t.first << ", " << t.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &t) {
os << "[";
for (__typeof(t.begin()) it = t.begin(); it != t.end(); it++) {
if (it != t.begin()) os << ", ";
os << *it;
}
os << "]";
return os;
}
const int MAXN = 1e5;
bool Here[MAXN];
int main() {
ios_base::sync_with_stdio(false);
string s;
int n;
cin >> s;
vector<int> C(26, 0);
n = s.size();
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'o' || s[i] == 'u' ||
s[i] == 'i') {
cnt = 0;
C = vector<int>(26, 0);
} else {
cnt++;
C[s[i] - 'a']++;
if (cnt >= 3) {
int num = 0;
for (int x : C) {
if (x > 0) {
num++;
}
}
if (num > 1) {
Here[i] = true;
cnt = 1;
C = vector<int>(26, 0);
C[s[i] - 'a']++;
}
}
}
}
for (int i = 0; i < n; i++) {
if (Here[i]) {
cout << ' ';
}
cout << s[i];
}
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:256000000")
#pragma gcc optimize("O3")
#pragma gcc target("sse4")
using namespace std;
mt19937 rng(2391);
mt19937 gnr(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename A>
istream& operator>>(istream& fin, vector<A>& v) {
for (auto it = v.begin(); it != v.end(); ++it) fin >> *it;
return fin;
}
template <typename A, typename B>
istream& operator>>(istream& fin, pair<A, B>& p) {
fin >> p.first >> p.second;
return fin;
}
template <typename A, typename B>
pair<A, B> operator+(const pair<A, B>& a, const pair<A, B>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
template <typename A, typename B>
pair<A, B> operator+=(pair<A, B>& a, const pair<A, B>& b) {
a.first += b.first;
a.second += b.second;
return a;
}
template <typename A, typename B>
pair<A, B> operator-(const pair<A, B>& a, const pair<A, B>& b) {
return make_pair(a.first - b.first, a.second - b.second);
}
template <typename A, typename B>
pair<A, B> operator-(const pair<A, B>& a) {
return make_pair(-a.first, -a.second);
}
template <typename A, typename B>
pair<A, B>& operator++(pair<A, B>& a) {
++a.first;
++a.second;
return a;
}
template <typename A, typename B>
pair<A, B>& operator--(pair<A, B>& a) {
--a.first;
--a.second;
return a;
}
template <typename A>
vector<A>& operator++(vector<A>& a) {
for (auto it = a.begin(); it != a.end(); ++it) ++*it;
return a;
}
template <typename A>
vector<A>& operator--(vector<A>& a) {
for (auto it = a.begin(); it != a.end(); ++it) --*it;
return a;
}
template <typename A, typename B>
pair<A, B> operator++(pair<A, B>& a, int) {
pair<A, B> b = a;
++a;
return b;
}
template <typename A, typename B>
pair<A, B> operator--(pair<A, B>& a, int) {
pair<A, B> b = a;
--a;
return b;
}
template <typename A>
vector<A>& operator++(vector<A>& a, int) {
vector<A> b = a;
++a;
return b;
}
template <typename A>
vector<A>& operator--(vector<A>& a, int) {
vector<A> b = a;
--a;
return b;
}
vector<vector<int>> adjlist_from_edgelist(const vector<pair<int, int>>& e,
const int& n) {
vector<vector<int>> g(n);
for (auto it = e.begin(); it != e.end(); ++it) {
g[it->first].push_back(it->second);
g[it->second].push_back(it->first);
}
return g;
}
template <typename A, typename B>
pair<A, B> operator-=(pair<A, B>& a, const pair<A, B>& b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
template <typename A>
A operator*(const pair<A, A>& p, const pair<A, A>& q) {
return p.first * q.first + p.second * q.second;
}
template <typename A>
pair<A, A> operator*(const pair<A, A>& p, const A& q) {
return make_pair(p.first * q, p.second * q);
}
template <typename A>
A operator%(const pair<A, A>& p, const pair<A, A>& q) {
return p.first * q.second - p.second * q.first;
}
template <typename A>
A sq_len(const pair<A, A>& p) {
return p * p;
}
template <typename A>
A sq_dist(const pair<A, A>& p, const pair<A, A>& q) {
return sq_len(p - q);
}
template <typename A>
double len(const pair<A, A>& p) {
return sqrt(sq_len(p));
}
template <typename A>
double dist(const pair<A, A>& p, const pair<A, A>& q) {
return len(p - q);
}
template <typename A>
bool is_rhombus(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c,
const pair<A, A>& d) {
A x = sq_dist(a, b);
A y = sq_dist(b, c);
A z = sq_dist(c, d);
A t = sq_dist(d, a);
return ((x == y) && (y == z) && (z == t));
}
template <typename A>
bool is_rectangle(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c,
const pair<A, A>& d) {
pair<A, A> x = a - b, y = b - c, z = c - d, t = d - a;
return ((x * y == 0) && (y * z == 0) && (z * t == 0) && (t * x == 0));
}
template <typename A>
bool are_parallel(const pair<A, A>& a, const pair<A, A>& b) {
return (a % b == 0);
}
template <typename A>
bool are_orthogonal(const pair<A, A>& a, const pair<A, A>& b) {
return (a * b == 0);
}
template <typename A>
bool are_codirected(const pair<A, A>& a, const pair<A, A>& b) {
return (are_parallel(a, b) && (a * b >= 0));
}
template <typename A>
bool is_parallelogram(const pair<A, A>& a, const pair<A, A>& b,
const pair<A, A>& c, const pair<A, A>& d) {
return ((a - b) == (d - c));
}
template <typename A>
bool is_trapezoid(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c,
const pair<A, A>& d) {
pair<A, A> x = a - b, z = d - c;
return are_codirected(x, z);
}
template <typename A>
bool is_convex_polygon(const pair<A, A>& a, const pair<A, A>& b,
const pair<A, A>& c, const pair<A, A>& d) {
pair<A, A> x = a - b, y = b - c, z = c - d, t = d - a;
A p = x % y, q = y % z, r = z % t, s = t % x;
return (((p >= 0) && (q >= 0) && (r >= 0) && (s >= 0)) ||
((p <= 0) && (q <= 0) && (r <= 0) && (s <= 0)));
}
template <typename A>
bool nprcs(const pair<A, A>& a, const pair<A, A>& c) {
return ((a % c) >= 0);
}
template <typename A>
bool nprcs(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c) {
return nprcs(a - b, a - c);
}
template <typename A>
bool npocs(const pair<A, A>& a, const pair<A, A>& c) {
return ((a % c) <= 0);
}
template <typename A>
bool npocs(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c) {
return npocs(a - b, a - c);
}
template <typename A>
bool prcs(const pair<A, A>& a, const pair<A, A>& c) {
return ((a % c) > 0);
}
template <typename A>
bool prcs(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c) {
return prcs(a - b, a - c);
}
template <typename A>
bool pocs(const pair<A, A>& a, const pair<A, A>& c) {
return ((a % c) < 0);
}
template <typename A>
bool pocs(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c) {
return pocs(a - b, a - c);
}
template <typename A>
bool different_sides(const pair<A, A>& a, const pair<A, A>& b,
const pair<A, A>& c, const pair<A, A>& d) {
pair<A, A> x = b - a;
A p = x % (c - b), q = x % (d - b);
return (((p >= 0) && (q <= 0)) || ((p <= 0) && (q >= 0)));
}
template <typename A>
bool sharply_different_sides(const pair<A, A>& a, const pair<A, A>& b,
const pair<A, A>& c, const pair<A, A>& d) {
pair<A, A> x = b - a;
A p = x % (c - b), q = x % (d - b);
return (((p > 0) && (q < 0)) || ((p < 0) && (q > 0)));
}
template <typename A>
pair<A, A> rot_90(const pair<A, A>& p) {
return make_pair(-p.second, p.first);
}
template <typename A>
pair<A, A> rot_90(const pair<A, A>& p, const pair<A, A>& c) {
return c + rot_90(p - c);
}
template <typename A>
bool intersecting_segments(const pair<A, A>& a, const pair<A, A>& b,
const pair<A, A>& c, const pair<A, A>& d) {
return different_sides(a, b, c, d) && different_sides(c, d, a, b);
}
template <typename A>
bool sharply_intersecting_segments(const pair<A, A>& a, const pair<A, A>& b,
const pair<A, A>& c, const pair<A, A>& d) {
return sharply_different_sides(a, b, c, d) &&
sharply_different_sides(c, d, a, b);
}
template <typename A>
pair<pair<A, A>, A> line_with_normal_vector_through_point(
const pair<A, A>& normal, const pair<A, A>& point) {
return make_pair(normal, -(normal * point));
}
template <typename A>
pair<pair<A, A>, A> serper(const pair<A, A>& a, const pair<A, A>& b) {
pair<A, A> p = b - a;
return make_pair(p + p, -(p * (a + b)));
}
pair<double, double> ints(const pair<double, double>& p, const double& a,
const pair<double, double>& q, const double& b) {
double D = p % q;
double E =
pair<double, double>(-a, p.second) % pair<double, double>(-b, q.second);
double F =
pair<double, double>(p.first, -a) % pair<double, double>(q.first, -b);
return pair<double, double>(E / D, F / D);
}
pair<double, double> circumcenter(const pair<double, double>& x,
const pair<double, double>& y,
const pair<double, double>& z) {
auto p1 = serper(x, y), p2 = serper(x, z);
return ints(p1.first, p1.second, p2.first, p2.second);
}
template <typename A>
pair<pair<A, A>, A> l_th_2(const pair<A, A>& p, const pair<A, A>& q) {
return make_pair(make_pair(q.second - p.second, p.first - q.first), -p % q);
}
template <typename A>
vector<pair<double, double>> circle_intersection(const pair<pair<A, A>, A>& a,
const pair<pair<A, A>, A>& b) {
pair<A, A> c = b.first - a.first;
A rr1 = a.second * a.second, rr2 = b.second * b.second, cc = c * c,
rrrr1 = rr1 * rr1, rrrr2 = rr2 * rr2, cccc = cc * cc,
D = 2 * (rr1 * rr2 + rr2 * cc + cc * rr1) - (rrrr1 + rrrr2 + cccc);
if (D >= 0) {
double E = (((double)(rr1 - rr2)) / cc + 1) / 2;
pair<double, double> baza =
pair<double, double>(a.first.first, a.first.second) +
pair<double, double>(c.first, c.second) * E;
if (D) {
double lll = sqrt((double)(D)) / (2 * cc);
pair<A, A> cr = rot_90(c);
pair<double, double> pmm =
pair<double, double>(cr.first, cr.second) * lll;
return {baza + pmm, baza - pmm};
} else
return vector<pair<double, double>>(1, baza);
} else
return vector<pair<double, double>>();
}
template <typename A, typename B>
pair<A, B> sopr(const pair<A, B>& p) {
return make_pair(p.first, -p.second);
}
template <typename A>
bool on_segment(const pair<A, A>& a, const pair<A, A>& b, const pair<A, A>& c) {
return are_codirected(b - a, c - b);
}
template <typename A>
pair<pair<A, A>, A> perpendicular(const pair<A, A>& line,
const pair<A, A>& point) {
return line_with_normal_vector_through_point(rot_90(line), point);
}
pair<double, double> projection(const pair<pair<double, double>, double>& line,
const pair<double, double>& point) {
pair<pair<double, double>, double> temp = perpendicular(line.first, point);
return ints(line.first, line.second, temp.first, temp.second);
}
pair<double, double> height(const pair<double, double>& a,
const pair<double, double>& b,
const pair<double, double>& c) {
return projection(l_th_2(a, c), b);
}
pair<double, double> unitvector(const pair<double, double>& a) {
return a * (1 / len(a));
}
template <typename T>
vector<int> z_function(const vector<T>& s) {
int n = ((int)(s.size()));
vector<int> z(n);
int l = 0, r = 1;
for (int i = 1; i < n; ++i) {
z[i] = max(0, min(r - i, z[i - l]));
while (i + z[i] < n && (s[i + z[i]] == s[z[i]])) ++z[i];
if (r < i + z[i]) {
l = i;
r = i + z[i];
}
}
return z;
}
pair<int, int> euc(const int& m, const int& n) {
if (n == 0) return pair<int, int>((m >= 0) ? 1 : -1, 0);
int t = m / n;
pair<int, int> ans1 = euc(n, m - t * n);
return pair<int, int>(ans1.second, ans1.first - ans1.second * t);
}
int prod(const int& a, const int& b, const int& M) {
return ((long long)(a)) * b % M;
}
int sum(const int& a, const int& b, const int& M) {
int c = a + b;
return c >= M ? c - M : c;
}
int raz(const int& a, const int& b, const int& M) {
int c = a - b;
return c < 0 ? c + M : c;
}
const int LITTLE_BORDER = 400;
struct factorizator {
int N;
vector<int> pr;
vector<int> md;
vector<int> pw;
vector<int> without_md;
factorizator(const int& n) : N(n), md(n), pw(n), without_md(n, 1) {
for (int i = 2; i < N; ++i) md[i] = i;
for (int i = 2; i < N; ++i) {
if (md[i] == i) pr.push_back(i);
bool worth = true;
for (int j = 0; worth && (j < ((int)(pr.size()))) && (pr[j] <= md[i]);
++j) {
long long temp = ((long long)(pr[j])) * i;
if (temp < N)
md[((int)temp)] = pr[j];
else
worth = false;
}
}
for (int i = 2; i < N; ++i) {
int t = md[i], s = i / t;
if (md[s] == t) {
pw[i] = 1 + pw[s];
without_md[i] = without_md[s];
} else {
pw[i] = 1;
without_md[i] = s;
}
}
}
void known_factorization(int n, vector<pair<unsigned long long, int>>& v) {
while (n > 1) {
v.emplace_back(md[n], pw[n]);
n = without_md[n];
}
}
vector<pair<unsigned long long, int>> pollardRho(const unsigned long long& n);
vector<pair<unsigned long long, int>> factor(unsigned long long n);
template <typename T>
vector<pair<T, int>> merge(const vector<pair<T, int>>& p1,
const vector<pair<T, int>>& p2) {
vector<pair<T, int>> ans;
int m = ((int)(p1.size()));
int n = ((int)(p2.size()));
int i = 0;
int j = 0;
while ((i < m) || (j < n)) {
if (i < m) {
if (j < n) {
if (p1[i].first < p2[j].first)
ans.push_back(p1[i++]);
else if (p1[i].first > p2[j].first)
ans.push_back(p2[j++]);
else {
ans.emplace_back(p1[i].first, p1[i].second + p2[j].second);
++i;
++j;
}
} else
ans.push_back(p1[i++]);
} else
ans.push_back(p2[j++]);
}
return ans;
}
};
factorizator fac(LITTLE_BORDER);
unsigned long long experimental_prodll(const unsigned long long& a,
const unsigned long long& b,
const unsigned long long& M,
const int& helper) {
if (M == 0) return 0;
unsigned long long q = ((long double)a) * b / M;
unsigned long long a1 = a * b - q * M;
unsigned long long a2 = a1;
int rm = M % helper;
int ra = a % helper;
int rb = b % helper;
int rq = q % helper;
int r1 = raz(prod(ra, rb, helper), prod(rq, rm, helper), helper);
int r2 = r1;
while (true) {
if (a1 % helper == r1 && a1 < M) return a1;
a1 -= M;
r1 = raz(r1, rm, helper);
a2 += M;
r2 = sum(r2, rm, helper);
if (a2 % helper == r2 && a2 < M) return a2;
}
}
inline int find_helper(const unsigned long long& M) {
int i = 30;
while (M % fac.pr[i] == 0) ++i;
return fac.pr[i];
}
unsigned long long prodll(const unsigned long long& a,
const unsigned long long& b,
const unsigned long long& M) {
if (M == 0) return 0;
unsigned long long helper = find_helper(M);
return experimental_prodll(a, b, M, helper);
}
unsigned long long sumll(const unsigned long long& a,
const unsigned long long& b,
const unsigned long long& M) {
if (a < M - b)
return a + b;
else
return a + b - M;
}
unsigned long long razll(const unsigned long long& a,
const unsigned long long& b,
const unsigned long long& M) {
if (a >= b)
return a - b;
else
return a + M - b;
}
template <typename T>
T diff(const T& a, const T& b) {
return (a > b) ? (a - b) : (b - a);
}
template <typename A>
bool angdis_cmp(const pair<A, A>& a, const pair<A, A>& b) {
A p;
if (p = a % b)
return (p > 0);
else
return sq_len(a) < sq_len(b);
}
template <typename T>
int find_min_idx(const vector<T>& v) {
int ans = 0, n = ((int)(v.size()));
for (int i = 1; i < n; ++i)
if (v[i] < v[ans]) ans = i;
return ans;
}
template <typename T>
vector<int> convex_hull(vector<pair<T, T>>& a) {
int n = ((int)(a.size()));
if (n) {
int mt = find_min_idx(a);
pair<T, T> d = a[mt];
for (int i = 0; i < n; ++i) a[i] -= d;
vector<int> idx(n);
for (int i = 0; i < n; ++i) idx[i] = i;
sort(idx.begin(), idx.end(),
[&](const int& l, const int& r) { return angdis_cmp(a[l], a[r]); });
vector<int> h(1, idx.front());
for (auto it = idx.begin() + 1; it != idx.end(); ++it) {
auto temp = a.begin() + *it;
if (((int)(h.size())) >= 2) {
if (are_parallel(a[h.back()], *temp)) h.pop_back();
while ((((int)(h.size())) >= 3) &&
npocs(a[h[((int)(h.size())) - 2]], a[h.back()], *temp))
h.pop_back();
}
h.push_back(*it);
}
for (int i = 0; i < n; ++i) a[i] += d;
return h;
} else
return vector<int>();
}
pair<int, int> cool_gcd(const int& a, const int& b) {
if (b) {
int c = a / b;
pair<int, int> ans1 = cool_gcd(b, a - b * c);
return pair<long long, long long>(ans1.second,
ans1.first - ans1.second * c);
} else
return pair<int, int>(1, 0);
}
pair<long long, long long> cool_gcdll(const long long& a, const long long& b) {
if (b) {
long long c = a / b;
pair<long long, long long> ans1 = cool_gcdll(b, a - b * c);
return pair<long long, long long>(ans1.second,
ans1.first - ans1.second * c);
} else
return pair<long long, long long>(1ll, 0ll);
}
template <typename T>
T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long pr_p(const long long& a, const long long& b, const long long& p) {
if (b < 1000000) return (a * b) % p;
long long temp = pr_p(a, b >> 1ll, p);
temp = sumll(temp, temp, p);
if (b & 1ll)
return sumll(temp, a, p);
else
return temp;
}
long long po_p(const long long& a, const long long& b, const long long& p) {
if (b < 2) {
if (b == 0)
return 1;
else
return a;
}
long long temp = po_p(a, b >> 1ll, p);
temp = pr_p(temp, temp, p);
if (b & 1ll)
return pr_p(temp, a, p);
else
return temp;
}
int pow_mod(const int& a, const int& b, const int& p) {
if (b < 2) {
if (b == 0)
return 1;
else
return a;
}
int temp = pow_mod(a, b >> 1, p);
temp = prod(temp, temp, p);
if (b & 1)
return prod(temp, a, p);
else
return temp;
}
long long pow_modll(const long long& a, const long long& b,
const long long& p) {
if (b < 2) {
if (b == 0)
return 1;
else
return a;
}
long long temp = pow_modll(a, b >> 1ll, p);
temp = prodll(temp, temp, p);
if (b & 1ll)
return prodll(temp, a, p);
else
return temp;
}
int inverse(int a, int n) {
int c = cool_gcd(a, n).first;
if (c < 0) c += n;
return c;
}
long long inversell(long long a, long long n) {
long long c = cool_gcdll(a, n).first;
if (c < 0) c += n;
return c;
}
template <typename A>
pair<int, int> equal_elements(const vector<A>& u, const vector<A>& v) {
pair<int, int> ans(INT_MAX, INT_MAX);
int m = ((int)(u.size())), n = ((int)(v.size()));
vector<int> id_u(m);
for (int i = 1; i < m; ++i) id_u[i] = i;
vector<int> id_v(n);
for (int i = 1; i < n; ++i) id_v[i] = i;
sort(id_u.begin(), id_u.end(),
[&](const int& x, const int& y) { return u[x] < u[y]; });
sort(id_v.begin(), id_v.end(),
[&](const int& x, const int& y) { return v[x] < v[y]; });
int i = 0;
int j = 0;
while ((i < m) && (j < n)) {
if (u[id_u[i]] < v[id_v[j]])
++i;
else if (v[id_v[j]] < u[id_u[i]])
++j;
else {
ans = min(ans, pair<int, int>(id_v[j], id_u[i]));
++j;
}
}
if (ans.first == INT_MAX)
return pair<int, int>(-1, -1);
else
return pair<int, int>(ans.second, ans.first);
}
long long discr_log(long long a, long long b, long long n) {
int k = ((int)(sqrt((long double)n)));
long long a1 = inversell(a, n);
int l = k + 20;
long long a2 = po_p(a1, k, n);
vector<long long> seq1(k), seq2(l);
seq1.front() = 1;
for (int i = 1; i < k; ++i) seq1[i] = pr_p(seq1[i - 1], a, n);
seq2.front() = b;
for (int i = 1; i < l; ++i) seq2[i] = pr_p(seq2[i - 1], a2, n);
pair<long long, long long> e = equal_elements(seq1, seq2);
if (e.first == -1)
return -1;
else
return e.first + e.second * k;
}
long long common_discr_log(long long a, long long b, long long n) {
const int C = 70;
a %= n;
b %= n;
if (gcd(n, a) != 1) {
for (int i = 0; i < C; ++i) {
if (po_p(a, i, n) == b) {
return i;
}
}
long long multp = po_p(a, C, n);
long long g = gcd(multp, n);
if (b % g) {
return -1;
} else {
b /= g;
n /= g;
multp /= g;
long long pop_back = inversell(multp, n);
b = pr_p(b, pop_back, n);
long long ans = discr_log(a, b, n);
if (ans == -1)
return -1;
else
return ans + C;
}
} else
return discr_log(a, b, n);
}
const unsigned long long minimum_composites[] = {1ull,
2046ull,
1373652ull,
25326000ull,
3215031750ull,
2152302898746ull,
3474749660382ull,
341550071728320ull,
341550071728320ull,
3825123056546413050ull,
3825123056546413050ull,
18446744073709551615ull};
const int little_primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
bool miller_rabin_check(const unsigned long long& n,
const unsigned long long& prime,
const unsigned long long& odd,
const unsigned long long& pot,
const unsigned long long& nmo) {
long long x = pow_modll(prime, odd, n);
if ((x == nmo) || (x == 1)) return true;
for (int i = 1; i < pot; ++i) {
x = prodll(x, x, n);
if (x == nmo) return true;
if (x == 1) return false;
}
return false;
}
bool is_prime(const unsigned long long& n) {
if (n <= 2) return (n == 2);
unsigned long long odd, pot, nmo;
nmo = n - 1;
odd = nmo;
pot = 0;
while ((odd & 1ll) == 0) {
odd >>= 1ll;
++pot;
}
int i = 0;
while (n > minimum_composites[i]) {
if (miller_rabin_check(n, little_primes[i], odd, pot, nmo) == false)
return false;
++i;
}
return true;
}
vector<pair<unsigned long long, int>> factorizator::pollardRho(
const unsigned long long& n) {
if (is_prime(n))
return vector<pair<unsigned long long, int>>(
1, pair<unsigned long long, int>(n, 1));
int step = 1;
while (true) {
step <<= 1;
unsigned long long a = rng();
unsigned long long b = a;
unsigned long long d = 1;
for (int j = 0; j < step; ++j) {
a = sumll(1, prodll(a, a, n), n);
b = sumll(1, prodll(b, b, n), n);
b = sumll(1, prodll(b, b, n), n);
d = gcd(diff(a, b), n);
if (d > 1) {
break;
}
}
if (1 < d && d < n) return merge(pollardRho(d), pollardRho(n / d));
}
return vector<pair<unsigned long long, int>>();
}
vector<pair<unsigned long long, int>> factorizator::factor(
unsigned long long n) {
vector<pair<unsigned long long, int>> ans;
for (int i = 0; n >= N && i < ((int)(pr.size())) && pr[i] < LITTLE_BORDER;
++i)
while (n % pr[i] == 0) {
if (((int)(ans.size())) && ans.back().first == pr[i])
++ans.back().second;
else
ans.emplace_back(pr[i], 1);
n /= pr[i];
}
if (n < N) {
known_factorization(n, ans);
return ans;
} else
return merge(ans, pollardRho(n));
}
template <typename T>
T phi(const vector<pair<T, int>>& v) {
T ans = 1;
for (int i = 0; i < ((int)(v.size())); ++i) {
ans *= v[i].first - 1;
for (int j = 1; j < v[i].second; ++j) ans *= v[i].first;
}
return ans;
}
unsigned long long phi(const unsigned long long& n) {
return phi(fac.factor(n));
}
bool check_primitive_root(const int& ph, const vector<int>& to_check,
const int& r, const int& n) {
for (int i = 0; i < ((int)(to_check.size())); ++i)
if (pow_mod(r, to_check[i], n) == 1) return false;
return (pow_mod(r, ph, n) == 1);
}
int primitive_root(const int& n) {
if (n < 3) return n - 1;
int p = phi(n);
vector<pair<unsigned long long, int>> f = fac.factor(p);
vector<int> to_check(((int)(f.size())));
for (int i = 0; i < ((int)(f.size())); ++i) to_check[i] = p / f[i].first;
for (int i = 2; i < n; ++i)
if (check_primitive_root(p, to_check, i, n)) return i;
return -1;
}
int unite_mod(const int& a, const int& p, const int& b, const int& q) {
pair<int, int> c = cool_gcd(p, q);
int pr = p * q;
int ans = ((a * c.second * q + b * c.first * p) % pr + pr) % pr;
return ans;
}
long long unite_modll(const long long& a, const long long& p,
const long long& b, const long long& q) {
pair<long long, long long> c = cool_gcdll(p, q);
long long pr = p * q;
long long ans = ((a * c.second * q + b * c.first * p) % pr + pr) % pr;
return ans;
}
pair<int, int> power_v(int n, const int& p) {
int ans = 0;
while (n % p == 0) {
n /= p;
++ans;
}
return pair<int, int>(ans, n);
}
int square_root_prime_modulo(int c, int n, const int& pr, const int& k) {
c %= n;
if (c) {
pair<int, int> kek = power_v(c, pr);
int l = kek.first;
if (l & 1) return -1;
if (l > 0) {
int pwl = 1;
for (int i = 0; i < l; ++i) pwl *= pr;
n /= pwl;
c /= pwl;
int ans1 = square_root_prime_modulo(c, n, pr, k - l);
if (ans1 == -1) return -1;
for (int i = 0; i < (l >> 1); ++i) ans1 *= pr;
return ans1;
} else {
int primitive;
if (n & 1)
primitive = primitive_root(n);
else
primitive = 5;
int u = ((int)discr_log(primitive, c, n));
if (u == -1) return -1;
if (u & 1) return -1;
return pow_mod(primitive, u >> 1, n);
}
} else
return 0;
}
int square_root_modulo(const int& c, const int& n) {
vector<pair<unsigned long long, int>> f = fac.factor(n);
int a = 0, p = 1;
for (int i = 0; i < ((int)(f.size())); ++i) {
int q = 1;
for (int j = 0; j < f[i].second; ++j) q *= f[i].first;
int b = square_root_prime_modulo(c, q, f[i].first, f[i].second);
if (b == -1) return -1;
a = unite_mod(a, p, b, q);
p *= q;
}
return a;
}
namespace BGF {
inline int cntd(unsigned x) {
int ans = 0;
while (x) {
if (x & 1) ++ans;
x >>= 1;
}
return ans;
}
inline long long cntdll(unsigned long long x) {
long long ans = 0;
while (x) {
if (x & 1) ++ans;
x >>= 1;
}
return ans;
}
inline int clzd(unsigned x) {
int ans = 32;
while (x) {
--ans;
x >>= 1;
}
return ans;
}
inline long long clzdll(unsigned long long x) {
long long ans = 64;
while (x) {
--ans;
x >>= 1;
}
return ans;
}
inline int ctzd(unsigned x) {
if (x == 0) return 32;
int ans = 0;
while ((x & 1) == 0) {
++ans;
x >>= 1;
}
return ans;
}
inline long long ctzdll(unsigned long long x) {
if (x == 0) return 64;
long long ans = 0;
while ((x & 1) == 0) {
++ans;
x >>= 1;
}
return ans;
}
} // namespace BGF
namespace BGF {
const unsigned BHC = 65535u;
const unsigned long long BHCL = 65535ull;
const unsigned BHN = 65536u;
const unsigned BHL = 16u;
const unsigned LH = 4294901760u;
const unsigned RH = 65535u;
const unsigned long long BHLL1 = 16ull;
const unsigned long long BHLL2 = 32ull;
const unsigned long long BHLL3 = 48ull;
const unsigned long long LHL = 18446744069414584320ull;
const unsigned long long RHL = 4294967295ull;
int CNT[BHN];
int CLZ[BHN];
int CTZ[BHN];
inline void initialize() {
CNT[0] = 0;
CLZ[0] = BHL + BHL;
CTZ[0] = BHL;
for (unsigned i = 1; i < BHN; ++i) {
CNT[i] = cntd(i);
CLZ[i] = clzd(i);
CTZ[i] = ctzd(i);
}
}
inline int cntc(const unsigned& x) {
return CNT[x & BHC] + CNT[(x >> BHL) & BHC];
}
inline long long cntcll(const unsigned long long& x) {
return CNT[x & BHCL] + CNT[(x >> BHLL1) & BHCL] + CNT[(x >> BHLL2) & BHCL] +
CNT[(x >> BHLL3) & BHCL];
}
inline int clzc(const unsigned& x) {
if (x & LH)
return CLZ[x >> BHL] - BHL;
else
return CLZ[x];
}
inline long long clzcll(const unsigned long long& x) {
if (x & LHL)
return clzc(x >> BHLL2);
else
return clzc(x) + BHLL2;
}
inline int ctzc(const unsigned& x) {
if (x & RH)
return CTZ[x & RH];
else
return CTZ[x >> BHL] + BHL;
}
inline long long ctzcll(const unsigned long long& x) {
if (x & RHL)
return ctzc(x);
else
return ctzc(x >> BHLL2) + BHLL2;
}
} // namespace BGF
const string INPUT_FILE = "input.txt";
const string OUTPUT_FILE = "output.txt";
struct point {
int x, y, z;
point() {}
bool operator<(const point& q) const {
if (x != q.x) return x < q.x;
if (y != q.y) return y < q.y;
return z < q.z;
}
};
int another_main() {
int n;
cin >> n;
set<pair<point, int>> p;
for (int i = 0; i < n; ++i) {
pair<point, int> g;
cin >> g.first.x >> g.first.y >> g.first.z;
g.second = i + 1;
p.insert(g);
}
while (((int)(p.size()))) {
auto r0 = p.begin();
auto r1 = r0;
++r1;
auto r2 = r1;
++r2;
if (r2 == p.end()) {
cout << r0->second << ' ' << r1->second << '\n';
return 0;
}
if (r2->first.x != r1->first.x) {
cout << r0->second << ' ' << r1->second << '\n';
p.erase(r0);
p.erase(r1);
} else if (r0->first.x != r1->first.x) {
auto r3 = r2;
++r3;
if ((r3->first.y != r2->first.y) || (r3->first.x != r2->first.x)) {
cout << r1->second << ' ' << r2->second << '\n';
p.erase(r1);
p.erase(r2);
} else {
cout << r2->second << ' ' << r3->second << '\n';
p.erase(r2);
p.erase(r3);
}
} else {
if ((r2->first.y != r1->first.y) || (r2->first.x != r1->first.x)) {
cout << r0->second << ' ' << r1->second << '\n';
p.erase(r0);
p.erase(r1);
} else {
cout << r1->second << ' ' << r2->second << '\n';
p.erase(r1);
p.erase(r2);
}
}
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
BGF::initialize();
int AMR = another_main();
return AMR;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Node {
int m, v, id;
bool operator<(const Node& P) const {
if (m != P.m) return m < P.m;
return v < P.v;
}
} A[maxn];
int n, k, h, tmp[maxn], ans[maxn];
inline bool check(double M) {
int cnt = k;
for (int i = n; i; i--) {
if (cnt <= A[i].v * M) {
tmp[cnt--] = A[i].id;
if (!cnt) {
memcpy(ans, tmp, sizeof(int) * (k + 1));
return 1;
}
}
}
return 0;
}
int main() {
while (~scanf("%d%d%d", &n, &k, &h)) {
for (int i = 1; i <= n; i++) A[i].id = i;
for (int i = 1; i <= n; i++) scanf("%d", &A[i].m);
for (int i = 1; i <= n; i++) scanf("%d", &A[i].v);
sort(A + 1, A + 1 + n);
double l = 1e-9, r = 1e5;
for (int i = 0; i < 100; i++) {
double mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
for (int i = 1; i <= k; i++) printf("%d%c", ans[i], i < k ? ' ' : '\n');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, m;
long long sum = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
sum += ((i + m) / 5) - (i / 5);
}
printf("%I64d", sum);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> res;
void solve() {
res.clear();
long long n, ans = 1;
cin >> n;
for (long long i = 0; i < n; i++) {
long long a, ins;
cin >> a;
ins = ((i + a) % n + n) % n;
if (res.count(ins) == 0) {
res[ins] = 1;
} else
ans = -1;
}
if (ans == -1) {
cout << "NO" << endl;
} else
cout << "YES" << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
std::vector<long long> tree[200005];
long long childs[200005];
std::vector<long long> contr;
long long n;
void dfs(long long u, long long par = -1) {
if (tree[u].size() == 1 && u != 1) {
childs[u] = 1;
return;
}
for (auto ch : tree[u]) {
if (ch != par) {
dfs(ch, u);
childs[u] += childs[ch];
contr.push_back(childs[ch] * (n - childs[ch]));
}
}
childs[u]++;
}
void solve() {
contr.clear();
cin >> n;
for (long long i = 0; i <= n; ++i) {
childs[i] = 0;
tree[i].clear();
}
for (long long i = 0; i < n - 1; ++i) {
long long x, y;
cin >> x >> y;
tree[x].push_back(y);
tree[y].push_back(x);
}
long long m;
cin >> m;
long long p[m];
for (long long i = 0; i < m; ++i) cin >> p[i];
sort(p, p + m);
dfs(1);
long long ans = 0;
sort(contr.begin(), contr.end());
if (m <= n - 1) {
for (long long i = 0; i < n - 1 - m; ++i) {
ans = (ans + contr[i]) % 1000000007;
}
for (long long i = n - 1 - m; i < n - 1; ++i) {
ans = (ans + (contr[i] * p[i - (n - 1 - m)]) % 1000000007) % 1000000007;
}
} else {
for (long long i = 0; i < n - 2; ++i) {
ans = (ans + (contr[i] * p[i]) % 1000000007) % 1000000007;
}
long long x = 1;
long long i = n - 2;
while (i < m) {
x = (x * p[i]) % 1000000007;
i++;
}
ans = (ans + (contr[n - 2] * x) % 1000000007) % 1000000007;
}
cout << ans << endl;
}
int32_t main() {
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 410;
const int mod = 998244353;
typedef long long LL;
inline int Pow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (LL)x * x % mod) if (y & 1) res = (LL)res * x % mod;
return res;
}
int dp[2][N][N][N], A[N], B[N], C[N][N];
int main() {
int n, s = 0; scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &A[i], &B[i]), s = (s + A[i]) % mod;
for (int i = 0; i <= 400; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
for (int i = 1, t = 0, t1 = 0; i <= n; t += B[i] - 1, t1 += A[i], i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k <= t1; k++) {
dp[0][i][j][k] = (dp[0][i][j][k] + dp[0][i - 1][j][k]) % mod;
dp[1][i][j][k] = (dp[1][i][j][k] + dp[1][i - 1][j][k]) % mod;
int p = (LL)k * Pow(k + A[i], mod - 2) % mod, p1 = Pow(p, j);
for (int l = 0; l < B[i]; l++) {
int w = (LL)C[j + l][j] * p1 % mod * Pow(1 + mod - p, l) % mod;
dp[0][i][j + l][k + A[i]] = (dp[0][i][j + l][k + A[i]] + (LL)dp[1][i - 1][j][k] * w) % mod;
dp[1][i][j + l][k + A[i]] = (dp[1][i][j + l][k + A[i]] + (LL)dp[0][i - 1][j][k] * w) % mod;
if (k == 0 && j == 0) dp[1][i][l][A[i]] = (dp[1][i][j + l][A[i]] + w) % mod;
}
}
int ans = 0;
for (int t = 0; t <= 1; t++)
for (int j = 0; j <= 400; j++)
for (int k = 0; k <= 400; k++) {
int w = (LL)dp[t][n][j][k] * s % mod * Pow(k, mod - 2) % mod;
if (t & 1) ans = (ans + w) % mod;
else ans = (ans - w + mod) % mod;
}
printf("%d\n", ans);
return 0;
}// | 0 |
#include <bits/stdc++.h>
int n, p[4005], f[4005][4005], w[4005], tl;
void solve() {
scanf("%d", &n);
n <<= 1;
for (int i = 1; i <= n; ++i) scanf("%d", &p[i]);
tl = 0;
int pre = 1;
w[++tl] = 1;
for (int i = 2; i <= n; ++i) {
if (p[i] < p[pre])
w[tl]++;
else {
pre = i;
w[++tl] = 1;
}
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= n; ++j) f[i][j] = 0;
f[0][0] = 1;
for (int i = 1; i <= tl; ++i)
for (int j = 0; j <= n; ++j)
f[i][j] = f[i - 1][j] | (j - w[i] >= 0 ? f[i - 1][j - w[i]] : 0);
if (f[tl][n / 2])
puts("YES");
else
puts("NO");
}
int main() {
int t;
scanf("%d", &t);
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:512000000")
using namespace std;
void solve(bool);
void precalc();
clock_t start;
int main() {
start = clock();
int t = 1;
cout.sync_with_stdio(0);
cin.tie(0);
precalc();
cout.precision(10);
cout << fixed;
int testNum = 1;
while (t--) {
solve(true);
}
cout.flush();
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
template <typename T>
void make_unique(vector<T>& a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
template <typename T>
void relax_min(T& cur, T val) {
cur = min(cur, val);
}
template <typename T>
void relax_max(T& cur, T val) {
cur = max(cur, val);
}
void precalc() {}
const long long C = 100500;
long long mod;
long long phi;
long long rem[C];
long long rev_rem[C];
vector<long long> primes, degs;
long long n;
long long get_deg(long long n, long long p) {
long long res = 0;
while (n) {
res += n / p;
n /= p;
}
return res;
}
long long getC(long long n, long long k) {
if (n < k) {
return 0;
}
long long res = rem[n] * rev_rem[k] % mod * rev_rem[n - k] % mod;
for (long long i = 0; i < primes.size(); ++i) {
long long deg = get_deg(n, primes[i]) - get_deg(k, primes[i]) -
get_deg(n - k, primes[i]);
res = res * binpow(primes[i], deg, mod) % mod;
}
return res;
}
long long get_res(long long l) {
long long res = 0;
for (long long par = 0; par < 2; ++par) {
for (long long cur = 0; 2 * cur + par <= n; ++cur) {
long long m = 2 * cur + par;
long long cur_l = l;
if ((cur_l + par) % 2) {
++cur_l;
}
long long now_c = (m + cur_l) / 2;
res += getC(n, m) * getC(m, now_c);
res %= mod;
}
}
return res;
}
void solve(bool read) {
long long l, r;
cin >> n >> mod >> l >> r;
rem[0] = 1;
long long M = mod;
phi = mod;
for (long long p = 2; p * p <= M; ++p) {
if (M % p == 0) {
phi = phi * (p - 1) / p;
primes.push_back(p);
degs.push_back(0);
while (M % p == 0) {
M /= p;
++degs.back();
}
}
}
if (M > 1) {
phi = phi * (M - 1) / M;
primes.push_back(M);
degs.push_back(1);
}
for (long long i = 1; i < C; ++i) {
long long cur = i;
for (long long p : primes) {
while (cur % p == 0) {
cur /= p;
}
}
rem[i] = rem[i - 1] * cur % mod;
}
for (long long i = 0; i < C; ++i) {
rev_rem[i] = binpow(rem[i], phi - 1, mod);
}
long long res = get_res(l) - get_res(r + 1);
res %= mod;
if (res < 0) {
res += mod;
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
if(s.substr(0,4)=="YAKI") printf("Yes\n");
else printf("No\n");
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
class calender{
public:
string s;
int ey,wy;
bool operator<(const calender &a)const{
return wy < a.wy;
}
};
int main(){
int n,q;
while(cin>>n>>q,n){
calender c[1005];
for(int i=0;i<n;i++)cin>>c[i].s>>c[i].ey>>c[i].wy;
sort(c,c+n);
for(int i=0;i<q;i++){
int query;
cin>>query;
for(int i=0;i<n;i++){
if(query <= c[i].wy){
if(c[i].wy - query < c[i].ey){
cout << c[i].s << " " << c[i].ey - (c[i].wy - query)<< endl;
}else{
cout << "Unknown" << endl;
}
break;
}
if(i==n-1)
cout << "Unknown" << endl;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1000011];
bool vis[1000011], one[1000011];
void dfs(int u) {
vis[u] = 1;
for (auto x : g[u]) {
if (!vis[x]) {
dfs(x);
}
}
}
long long c2(long long x) { return (x * (x - 1)) / 2; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, n, m, u, v;
cin >> n >> m;
vector<pair<int, int> > edge;
long long self = 0;
long long nonself = 0;
for (i = 0; i < m; i++) {
cin >> u >> v;
edge.push_back({u, v});
if (u == v) {
one[u] = 1;
self++;
continue;
}
g[u].push_back(v);
g[v].push_back(u);
nonself++;
}
for (i = 1; i <= n; i++) {
if (g[i].size() > 0 || one[i] == 1) {
dfs(i);
break;
}
}
for (auto x : edge) {
if (!vis[x.first] || !vis[x.second]) {
cout << 0;
return 0;
}
}
long long ans = 0;
for (i = 1; i <= n; i++) {
ans += c2(g[i].size());
}
ans += c2(self);
ans += self * nonself;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAXN = 2e5 + 10;
int n, h, l[MAXN], r[MAXN];
int32_t main() {
scanf("%d", &n);
set<int> s;
for (int i = 1; i < n; i++) {
s.insert(i);
}
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &l[i], &r[i]);
if (r[i] != n) {
cout << "NO";
return 0;
}
if (l[i] == n) {
cout << "NO";
return 0;
}
s.erase(l[i]);
}
sort(l, l + n, greater<int>());
int last = n;
vector<pair<int, int>> ans;
for (int i = 0; i < n - 1;) {
int j = i;
while (j + 1 < n && l[j + 1] == l[j]) j++;
for (int k = 1; k < (j - i + 1); k++) {
if (s.empty() || *s.rbegin() > l[i]) {
return cout << "NO", 0;
} else {
ans.push_back({last, *s.rbegin()});
last = *s.rbegin();
s.erase(*s.rbegin());
}
}
ans.push_back({last, l[i]});
last = l[i];
i = j + 1;
}
cout << "YES\n";
for (auto x : ans) {
cout << x.first << " " << x.second << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1000 + 20;
bool t[max_n];
int n, x;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
t[x] = true;
}
for (int i = 0; i <= 1000; i++) {
if (t[i] && t[i + 1] && t[i + 2]) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long Data[400100], dp[400100], Num[400100], Sum[400100];
long long N, I;
int main() {
scanf("%I64d%I64d", &N, &I);
for (register int i = 1; i <= N; ++i) scanf("%I64d", &Data[i]);
sort(Data + 1, Data + N + 1);
int Index = 0, Count = 0;
Data[0] = -1;
for (register int i = 1; i <= N; ++i) {
if (Data[i] != Data[i - 1]) {
Num[Index] = Count;
Count = 1;
++Index;
} else
++Count;
}
Num[Index] = Count;
long long k = 8LL * I / N, K;
if (k > 20LL)
K = Index;
else
K = min(1LL << k, (long long)Index);
for (register int i = 1; i <= Index; ++i) Sum[i] = Sum[i - 1] + Num[i];
dp[K] = Sum[Index] - Sum[K];
long long Ans = 2147483647LL;
for (register long long i = K + 1; i <= Index; ++i) {
dp[i] = dp[i - 1] + Num[i - K] - Num[i];
Ans = min(Ans, dp[i]);
}
if (Ans == 2147483647LL) Ans = 0LL;
printf("%I64d\n", Ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 5001;
const int INF = 1e9 + 7;
int n;
vector<int> v[MXN];
int down[MXN];
bool u[MXN];
set<pair<int, int> > res;
void dfs1(int x, int p = -1) {
down[x] = 1;
for (auto go : v[x]) {
if (p == go) continue;
dfs1(go, x);
down[x] += down[go];
}
}
void dfs(int x, int p = -1) {
vector<int> q;
for (auto go : v[x]) {
if (p == go) continue;
dfs(go, x);
q.push_back(down[go]);
}
if (q.empty()) return;
memset(u, 0, sizeof u);
if (p > 0) q.push_back(n - down[x]);
u[0] = 1;
for (auto it : q) {
for (int second = n - 2; second >= 1; second--) {
if (second - it < 0) continue;
if (u[second - it]) {
u[second] = 1;
res.insert({n - 1 - second, second});
res.insert({second, n - 1 - second});
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs1(1);
dfs(1);
printf("%d\n", (int)res.size());
for (auto it : res) {
printf("%d %d\n", it.first, it.second);
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
vector<int>tree[100005];
long long int dp[100005][2];
int MOD = 1e9+7;
void dfs(int v, int pv){
dp[v][0] = 1;
dp[v][1] = 1;
for(auto u : tree[v]){
if(u != pv){
dfs(u, v);
dp[v][0] = (dp[v][0] * (dp[u][0] + dp[u][1]) % MOD) % MOD;
dp[v][1] = (dp[v][1] * dp[u][0]) % MOD;
}
}
}
int main(){
int N, a, b;
cin >> N;
for(int i = 0; i < N-1; i++){
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
dfs(1, 0);
cout << (dp[1][0] + dp[1][1]) % MOD ;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long, long> > m;
int main() {
long n, i, count = 0, x, y, max;
cin >> n;
while (n--) {
cin >> x >> y;
m.push_back(make_pair(x, y));
}
sort(m.begin(), m.end());
max = m[0].second;
for (i = 1; i < m.size(); i++) {
if (m[i].second < max) {
count++;
} else
max = m[i].second;
}
cout << count;
}
| 3 |
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <utility>
#include <algorithm>
using namespace std;
typedef pair<int,int> P;
int X1[1000],X2[1000],Y1[1000],Y2[1000];
int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
bool F[6000][6000];
int W,H,N;
int compress(int *X1,int *X2,int W) {
vector<int> VX;
for(int i=0;i<N;i++) {
for(int d=-1;d<=1;d++) {
int nx1=X1[i]+d,nx2=X2[i]+d;
if(0<=nx1 && nx1<W) VX.push_back(nx1);
if(0<=nx2 && nx2<W) VX.push_back(nx2);
}
}
sort(VX.begin(),VX.end());
VX.erase(unique(VX.begin(),VX.end()),VX.end());
for(int i=0;i<N;i++) {
X1[i]=find(VX.begin(),VX.end(),X1[i])-VX.begin();
X2[i]=find(VX.begin(),VX.end(),X2[i])-VX.begin();
}
return VX.size();
}
int main() {
while(scanf("%d %d",&W,&H),W|H) {
scanf("%d",&N);
for(int i=0;i<N;i++) {
scanf("%d %d %d %d",&X1[i],&Y1[i],&X2[i],&Y2[i]);
}
W=compress(X1,X2,W);
H=compress(Y1,Y2,H);
memset(F,0,sizeof(F));
for(int i=0;i<N;i++) {
for(int y=Y1[i];y<Y2[i];y++) for(int x=X1[i];x<X2[i];x++) {
F[x][y]=1;
}
}
int ans=0;
for(int y=0;y<H;y++) for(int x=0;x<W;x++) {
if(F[x][y]) continue;
ans++;
queue<P> Q;
Q.push(P(x,y));
while(!Q.empty()) {
P p=Q.front();Q.pop();
for(int i=0;i<4;i++) {
int nx=p.first+dx[i],ny=p.second+dy[i];
if(0>nx||nx>=W||0>ny||ny>=H) continue;
if(F[nx][ny]) continue;
F[nx][ny]=true;
Q.push(P(nx,ny));
}
}
}
printf("%d\n",ans);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, x;
void purple() {
cin >> n;
long long int x = 1;
while ((x * (x - 1)) / 2 <= n) {
x++;
}
x--;
long long int left = n - ((x * (x - 1)) / 2);
cout << "133";
while (left > 0) {
cout << "7";
left--;
}
for (long long int i = 0; i < x - 2; i++) {
cout << "3";
}
cout << "7\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int t = 1;
cin >> t;
while (t--) purple();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[200];
int a[200];
while (~scanf("%s", s)) {
memset(a, 0, sizeof(a));
int len = strlen(s);
int num = 0;
for (int i = 0; i < len - 1; i++) {
if (s[i] == 'V' && s[i + 1] == 'K') {
a[i] = a[i + 1] = 1;
num++;
i++;
}
}
for (int i = 0; i < len - 1; i++) {
if ((s[i] == 'V' || s[i + 1] == 'K') && a[i] == 0 && a[i + 1] == 0) {
num++;
break;
}
}
cout << num << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long a[26] = {0}, c = 0;
for (long long i = 0; i < s.length(); i++) {
a[s[i] - 'a']++;
}
for (long long i = 0; i < 26; i++) {
if (a[i] & 1) c++;
}
if ((c & 1) || (c == 0))
cout << "First";
else
cout << "Second";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
double EPS = 1e-7;
int INF = 1000000000;
int MOD = 1000000007;
int MAXINT = 2147483647;
long long INFLL = 1000000000000000000LL;
long long MAXLL = 9223372036854775807LL;
int mx[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
int my[8] = {0, 0, -1, 1, -1, 1, -1, 1};
char s[1005];
int dp[1005];
int main() {
scanf("%s", s);
int len = strlen(s);
int ans = 0;
for (int(a) = (0); (a) <= (len - 1); (a)++) {
int maks = 0;
for (int(b) = (0); (b) <= (a - 1); (b)++) {
if ((a - b) % 2 == 1 && s[a] == s[b]) (maks) = max((maks), (dp[b]));
}
dp[a] = maks + 1;
(ans) = max((ans), (dp[a]));
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long z = 0, o = 0, ans = 0;
for (long long i = 0; i < s.size(); i++) {
if (s[i] == '0')
z++;
else
o++;
}
ans = min(z, o);
if (ans % 2)
cout << "DA" << endl;
else
cout << "NET" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void IN(T& p) {
register T n = 0, sign = 1, a = getchar();
while ((a < '0') or (a > '9')) {
if (a == '-') {
sign = -1;
a = getchar();
break;
}
a = getchar();
}
while ((a >= '0') and (a <= '9')) {
n = (n << 1) + (n << 3) + a - '0';
a = getchar();
}
p = n * sign;
}
template <typename T>
inline void OUT(T n) {
register char d[20];
register int8_t i = 0;
if (n < 0) {
putchar('-');
n = -n;
}
do {
d[i++] = n % 10 + '0';
n = n / 10;
} while (n);
while (i) putchar(d[--i]);
putchar('\n');
}
int main() {
int n, ans = INT_MAX;
IN(n);
vector<int> v(n);
for (int i = 0; i < (n); ++i) IN(v[i]);
sort((v).begin(), (v).end());
for (int i = 0; i < (n / 2); ++i) {
if ((v[i + n / 2] - v[i]) < ans) ans = (v[i + n / 2] - v[i]);
};
OUT(ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
static struct IO {
char tmp[1 << 10];
char cur;
inline char nextChar() { return cur = getc(stdin); }
inline char peekChar() { return cur; }
inline operator bool() { return peekChar(); }
inline static bool isBlank(char c) { return (c < '-' && c); }
inline bool skipBlanks() {
while (isBlank(nextChar()))
;
return peekChar() != 0;
}
inline IO& operator>>(char& c) {
c = nextChar();
return *this;
}
inline IO& operator>>(char* buf) {
if (skipBlanks()) {
if (peekChar()) {
*(buf++) = peekChar();
while (!isBlank(nextChar())) *(buf++) = peekChar();
}
*(buf++) = 0;
}
return *this;
}
inline IO& operator>>(string& s) {
if (skipBlanks()) {
s.clear();
s += peekChar();
while (!isBlank(nextChar())) s += peekChar();
}
return *this;
}
inline IO& operator>>(double& d) {
if ((*this) >> tmp) sscanf(tmp, "%lf", &d);
return *this;
}
inline IO& operator>>(int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(unsigned int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(long long& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline void putChar(char c) { putc(c, stdout); }
inline IO& operator<<(char c) {
putChar(c);
return *this;
}
inline IO& operator<<(const char* s) {
while (*s) putChar(*s++);
return *this;
}
inline IO& operator<<(const string& s) {
for (int i = 0; i < (int)s.size(); ++i) putChar(s[i]);
return *this;
}
char* toString(double d) {
sprintf(tmp, "%lf%c", d, '\0');
return tmp;
}
inline IO& operator<<(double d) { return (*this) << toString(d); }
inline char* toString(int n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(int n) { return (*this) << toString(n); }
inline char* toString(long long n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(long long n) { return (*this) << toString(n); }
} __io__;
int n, m, d, u, v;
int P[MAXN][18];
vector<int> lvl(MAXN), par(MAXN);
vector<vector<int> > g(MAXN);
void make() {
for (int i = 1; i <= n; ++i) {
for (int j = 0; (1 << j) < n; ++j) {
P[i][j] = -1;
}
}
for (int i = 1; i <= n; ++i) {
P[i][0] = par[i];
}
for (int j = 1; (1 << j) < n; ++j) {
for (int i = 1; i <= n; ++i) {
P[i][j] = P[P[i][j - 1]][j - 1];
}
}
}
void root(int node, int prev) {
for (int i = 0; i < g[node].size(); ++i) {
if (g[node][i] != prev) {
par[g[node][i]] = node;
lvl[g[node][i]] = lvl[node] + 1;
root(g[node][i], node);
}
}
}
bool same = true;
int LCA(int a, int b) {
int shift = lvl[a] - lvl[b];
same = false;
if (!shift) same = true;
int LOG = 1;
for (;;) {
if ((1 << (LOG - 1) > shift)) break;
LOG++;
}
for (int j = LOG; j >= 0; --j) {
if ((1 << j) < shift) {
shift -= (1 << j);
a = P[a][j];
}
}
if (!same) a = par[a];
if (a == b) return a;
LOG = 1;
int D = lvl[a];
for (;;) {
if ((1 << (LOG - 1)) > D) {
break;
}
LOG++;
}
for (int j = LOG; j >= 0; --j) {
if ((P[a][j] != -1) and (P[a][j] != P[b][j])) {
a = P[a][j], b = P[b][j];
}
}
return par[a];
}
int max_distance, opt_node;
int DISTANCE(int na, int nb) {
if (lvl[na] < lvl[nb]) {
swap(na, nb);
}
int anc = LCA(na, nb);
return lvl[na] + lvl[nb] - 2 * lvl[anc];
}
int damaged[MAXN];
int main() {
__io__ >> n >> m >> d;
for (int i = 0; i < m; ++i) {
__io__ >> damaged[i];
}
for (int i = 0; i < n - 1; ++i) {
__io__ >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i <= n; ++i) {
par[i] = i;
}
root(1, -1);
make();
int node_a, node_b, max_level = -1;
max_distance = -1;
for (int i = 0; i < m; ++i) {
if (lvl[damaged[i]] > max_level) {
node_a = damaged[i];
max_level = lvl[damaged[i]];
}
}
int dist;
for (int i = 0; i < m; ++i) {
dist = DISTANCE(damaged[i], node_a);
if (dist > max_distance) {
node_b = damaged[i];
max_distance = dist;
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (((DISTANCE(i, node_a)) <= d) and (DISTANCE(i, node_b) <= d)) {
ans++;
}
}
__io__ << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
long long int power(long long int a, long long int n) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long int power(long long int a, long long int n, long long int mod) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
vector<long long int> scanVector(long long int n, vector<long long int> &v) {
long long int temp;
for (long long int i = 0; i < n; i++) {
cin >> temp;
v.push_back(temp);
}
return v;
}
bool isPalindrome(string s) {
string temp = s;
reverse(temp.begin(), temp.end());
if (s == temp) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
while (t--) {
long long int n, m;
cin >> n >> m;
map<string, long long int> m1;
vector<string> s1;
for (long long int i = 0; i < n; i++) {
string s;
cin >> s;
s1.push_back(s);
m1[s]++;
}
long long int ct = 0;
long long int palindromeLen = 0;
string s2 = "";
string pal = "";
for (long long int i = 0; i < s1.size(); i++) {
string temp = s1[i];
reverse(temp.begin(), temp.end());
if (temp != s1[i]) {
if (m1[s1[i]] != 0 && m1[temp] != 0) {
m1[s1[i]]--;
m1[temp]--;
s2 += s1[i];
ct += (long long int)(2 * temp.length());
}
} else {
if (palindromeLen < (long long int)s1[i].length()) {
palindromeLen = max(palindromeLen, (long long int)s1[i].length());
pal = s1[i];
}
}
}
string res = s2;
reverse(s2.begin(), s2.end());
res += pal;
res += s2;
cout << ct + palindromeLen << endl;
cout << res << endl;
}
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int a;
cin >> a;
cout << a *(1 + a * (1 + a)) << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, s, p, tot, h[200005], fa[200005], cnt[200005];
vector<long long> v[200005];
struct edge {
long long u, v;
} e[200005 << 1];
template <typename T>
inline void read(T &x) {
register T c = getchar();
for (; c < 48 || 57 < c;) c = getchar();
for (x = 0; 48 <= c && c <= 57; c = getchar())
x = (x << 3) + (x << 1) + (c & 15);
}
template <typename T>
inline void print(T x) {
if (x > 9) print(x / 10);
putchar(x % 10 | 48);
}
inline long long fnd(long long x) { return x ^ fa[x] ? fa[x] = fnd(fa[x]) : x; }
inline long long add(long long u, long long v) {
e[++tot] = (edge){h[u], v}, h[u] = tot;
}
inline void dfs(long long x, long long f) {
if (cnt[p] == s) ++p;
v[p].push_back(x), ++cnt[p];
for (register long long i = h[x]; i; i = e[i].u) {
if (e[i].v == f) continue;
dfs(e[i].v, x);
if (cnt[p] == s) ++p;
v[p].push_back(x), ++cnt[p];
}
}
signed main() {
read(n), read(m), read(k), s = ((n << 1) - 1) / k + 1, p = 1;
for (register long long i = 1; i <= n; ++i) fa[i] = i;
for (register long long x, y, fx, fy; m--;) {
read(x), read(y), fx = fnd(x), fy = fnd(y);
if (fx ^ fy) add(x, y), add(y, x), fa[fx] = fy;
}
dfs(1, 0);
for (register long long i = 1; i <= k; ++i, puts(""))
if (cnt[i]) {
print(cnt[i]), putchar(' ');
for (register long long j = 0; j < v[i].size(); ++j)
print(v[i][j]), putchar(' ');
} else
print(1), putchar(' '), print(1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)6e6 + 15;
const int BASE = (int)20;
const int inf = 0x3f3f3f3f;
int t[N];
long long pref[N];
inline long long mceil(long long x, long long y) {
return x / y + (x % y != 0);
}
int main() {
int n, k, b, c;
scanf("%d", &n), scanf("%d", &k), scanf("%d", &b), scanf("%d", &c);
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
sort(t + 1, t + 1 + n);
for (int i = 1; i <= n; i++) {
pref[i] = pref[i - 1] + t[i];
}
long long ans = (long long)9e18;
for (int l = -(int)1e9 - 4; l <= -(int)1e9; l++) {
long long x = l;
long long delta = 0;
multiset<long long> st;
long long stSum = 0;
for (int i = 1; i <= n; i++) {
if (t[i] > x) {
long long kk = mceil(t[i] - x, 5);
delta += kk * b;
x = x + 5 * kk;
}
long long cost = (x - t[i]) * c - delta;
st.insert(cost);
stSum += cost;
if ((int)st.size() > k) {
auto it = st.rbegin();
stSum -= *it;
st.erase(st.find(*it));
}
if ((int)st.size() == k) {
ans = min(ans, stSum + k * delta);
}
}
}
for (int i = k; i <= n; i++) {
ans = min(ans, 1LL * (1LL * k * t[i] - (pref[i] - pref[i - k])) * c);
}
printf("%lld\n", ans);
}
| 4 |
Subsets and Splits