solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
// Problem: B. The Great Hero
// Contest: Codeforces - Codeforces Round #700 (Div. 2)
// URL: https://codeforces.com/contest/1480/problem/B
// Memory Limit: 512 MB
// Time Limit: 2000 ms
//
// Author: masked_huh
// Created: 08-02-2021 12:41:11
/*Success isn't permanent, failure isn't fatal,
it's the courage to continue that counts.*/
#include <bits/stdc++.h>
using namespace std;
#define pfin(a) printf("%d\n",a);
#define pfln(a) printf("%lld\n",a);
#define pfis(a) printf("%d ",a);
#define pfls(a) printf("%lld ",a);
#define sfi(a) scanf("%d",&a);
#define sfl(a) scanf("%lld",&a);
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define f(i,a,b) for(int i=a;i<b;i++)
#define pb(a) push_back(a);
#define mp(a,b) make_pair(a,b)
typedef long long ll;
#define F first
#define S second
#define vi vector<int>
#define vc vector<char>
const ll mod = 1e9 + 7;
struct util
{
ll hlth,att;
};
bool cmp(util a,util b)
{
return a.att<b.att;
}
void solve()
{
ll a,b,n;
sfl(a)
sfl(b)
sfl(n)
util arr[n];
f(i,0,n)
sfl(arr[i].att)
f(i,0,n)
sfl(arr[i].hlth)
sort(arr,arr+n,cmp);
for(int i=0;i<n-1;i++)
{
ll var=arr[i].hlth/a;
if(((arr[i].hlth)%a)!=0)
var++;
b=b-var*arr[i].att;
if(b<=0)
{
printf("NO\n");
return;
}
}
ll var=arr[n-1].hlth/a;
if(((arr[n-1].hlth)%a)!=0)
var++;
var--;
ll temp=b-(var*arr[n-1].att);
if(temp<=0)
{
printf("NO\n");
return;
}
printf("YES\n");
return;
}
int main()
{
int t=1;
sfi(t)
while(t--)
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
const long long mod = 1000000007;
int m;
long long dp[15][15];
long long ans;
long long amount[15];
bool isLucky(int x) { return x == 4 || x == 7; }
void plus(long long &a, long long b) {
a += b;
a %= mod;
}
void search(int limit, int current, int position, long long total) {
if (position > 6) {
plus(ans, total);
return;
}
for (int i(0); i < limit - current; ++i) {
if (amount[i]) {
long long temp = total * amount[i] % mod;
amount[i]--;
search(limit, current + i, position + 1, temp);
amount[i]++;
}
}
}
int main() {
scanf("%d", &m);
for (int i(1); i < 10; ++i)
for (int j(0); j < 10; ++j) {
if (j) dp[i][isLucky(j)]++;
for (int k(0); k < 10; ++k) dp[i][k + isLucky(j)] += dp[i - 1][k];
}
int len = 0, num[15];
for (int tmp(m); tmp; tmp /= 10) num[++len] = tmp % 10;
for (int i(0); i < 10; ++i) amount[i] = dp[len - 1][i];
int tLucky = 0;
for (int i(len); i; --i) {
for (int j(i < len ? 0 : 1); j < num[i]; ++j) {
if (j) amount[tLucky + isLucky(j)]++;
for (int k(0); k < 10; ++k)
amount[tLucky + isLucky(j) + k] += dp[i - 1][k];
}
tLucky += isLucky(num[i]);
if (num[i]) amount[tLucky]++;
}
for (int i(1); i <= 9; ++i) search(i, 0, 1, amount[i]);
printf("%I64d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long gcd(long long x, long long y) {
while (y) x %= y, swap(x, y);
return x;
}
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first + b.first, a.second + b.second);
}
pair<long long, long long> operator-(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first - b.first, a.second - b.second);
}
long long operator*(pair<long long, long long> a,
pair<long long, long long> b) {
return a.first * b.second - a.second * b.first;
}
template <class T>
int sign(T x) {
return x < 0 ? -1 : x > 0 ? 1 : 0;
}
int ccw(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return sign((b - a) * (c - b));
}
template <class T>
void setmin(T &x, T y) {
if (x > y) x = y;
}
template <class T>
void setmax(T &x, T y) {
if (x < y) x = y;
}
template <class T>
void addval(T &x, T y) {
x += y;
x %= mod;
}
size_t getCurrentTime() {
return chrono::steady_clock::now().time_since_epoch().count();
}
struct __RandomLong__ {
mt19937_64 rnd;
__RandomLong__() : rnd(getCurrentTime()) {}
long long operator()(long long Min, long long Max) {
return uniform_int_distribution<long long>(Min, Max)(rnd);
}
long long operator()() { return (*this)(LONG_LONG_MIN, LONG_LONG_MAX); }
} randomLong;
struct my_hash {
static uint64_t splitmix(uint64_t x) {
x += 0x9e3779b97f4a7c15ull;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ull;
x = (x ^ (x >> 27)) * 0x94d049bb133111ebull;
return x ^ (x >> 31);
}
size_t operator()(long long x) const {
static long long T = getCurrentTime();
return splitmix(x + T);
}
};
int n;
long long s;
bool ok(int x) {
long long sum = 0, mx = 1;
int num = 0, i = 1;
while (1) {
if (num + mx >= n) {
sum += (long long)(n - num) * i;
break;
}
sum += mx * i;
num += mx;
i++;
mx *= x;
}
return sum <= s;
}
int H[100005];
long long M[100005];
int CNT[100005];
vector<int> Hs[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed, ios::floatfield);
cout.precision(20);
cin >> n >> s;
if (s < 2 * n - 1 || n * (n + 1ll) / 2ll < s) {
cout << "No";
return 0;
}
cout << "Yes" << endl;
int st = 1, ed = n - 1;
while (st < ed) {
int md = st + ed >> 1;
if (ok(md))
ed = md;
else
st = md + 1;
}
H[1] = M[1] = 1;
for (int i = 2; i <= n; i++)
H[i] = 1, M[i] = min(M[i - 1] * st, (long long)n);
long long sum = n * (n + 1ll) / 2ll;
int hm = 2, hl = n;
while (sum > s) {
while (hm <= n && H[hm] >= M[hm]) hm++;
long long sm = hl - hm;
if (sum - s <= sm) {
H[hl]--;
H[hl - (sum - s)]++;
sum = s;
} else {
int st = 1, ed = H[hl];
while (st < ed) {
int md = st + ed + 1 >> 1;
if (sm * md <= sum - s)
st = md;
else
ed = md - 1;
}
H[hl] -= st;
H[hm] += st;
sum -= sm * st;
}
if (H[hl] == 0) hl--;
}
Hs[1].push_back(1);
int P = 1;
for (int i = 2; H[i]; i++) {
for (int j = 0; j < H[i]; j++) {
P++;
while (CNT[Hs[i - 1].back()] >= st) Hs[i - 1].pop_back();
cout << Hs[i - 1].back() << ' ';
CNT[Hs[i - 1].back()]++;
Hs[i].push_back(P);
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, P = 1e9 + 7;
inline void write(long long x) {
if (x > 9) write(x / 10ll);
putchar(x % 10ll + '0');
}
struct miaow {
int l, r;
mutable long long sum;
miaow(int l = 0, int r = 0, long long sum = 0) : l(l), r(r), sum(sum) {}
inline bool operator<(const miaow& qwe) const { return l < qwe.l; }
};
int n, m;
set<miaow> kdl;
set<miaow>::iterator fg(int x) {
set<miaow>::iterator qwe = kdl.lower_bound(miaow(x, 0, 0));
if (qwe != kdl.end() && qwe->l == x) return qwe;
--qwe;
int l = qwe->l, r = qwe->r;
long long sum = qwe->sum;
kdl.erase(qwe);
kdl.insert(miaow(l, x - 1, sum));
return kdl.insert(miaow(x, r, sum)).first;
}
void xg(int l, int r, long long sum) {
set<miaow>::iterator rrr = fg(r + 1), lll = fg(l);
kdl.erase(lll, rrr);
kdl.insert(miaow(l, r, sum));
}
void add(int l, int r, long long sum) {
set<miaow>::iterator rrr = fg(r + 1), lll = fg(l);
for (set<miaow>::iterator i = lll; i != rrr; ++i) {
i->sum += sum;
}
}
long long qpow(long long qwe, long long asd, long long p) {
long long sum = 1;
qwe %= p;
while (asd) {
if (asd & 1) sum = sum * qwe % p;
qwe = qwe * qwe % p;
asd >>= 1ll;
}
return sum;
}
long long cf(int l, int r, long long x, long long y) {
long long ans = 0;
set<miaow>::iterator rrr = fg(r + 1), lll = fg(l);
for (set<miaow>::iterator i = lll; i != rrr; ++i) {
long long gs = ((i->r) - (i->l) + 1), sum = i->sum;
ans = (ans + qpow(sum, x, y) * gs) % y;
}
return ans;
}
struct meow {
long long a;
int b;
meow(long long a = 0, int b = 0) : a(a), b(b) {}
inline bool operator<(const meow& qwe) const { return a < qwe.a; }
};
meow dl[N];
int dlh = 0;
long long pm(int l, int r, int x) {
dlh = 0;
set<miaow>::iterator rrr = fg(r + 1), lll = fg(l);
for (set<miaow>::iterator i = lll; i != rrr; ++i) {
dl[dlh++] = meow(i->sum, (i->r) - (i->l) + 1);
}
sort(dl, dl + dlh);
for (int i = 0; i < dlh; ++i) {
x -= dl[i].b;
if (x <= 0) return dl[i].a;
}
}
void sc() {
for (set<miaow>::iterator i = kdl.begin(); i != kdl.end(); ++i) {
int gs = i->r - i->l + 1, sum = i->sum;
for (int j = 0; j < gs; ++j) {
cout << sum << " ";
}
}
cout << endl;
}
long long seed, umax;
long long rnd() {
long long sum = seed;
seed = (seed * 7 + 13) % P;
return sum;
}
void csh() {
cin >> n >> m >> seed >> umax;
for (int i = 1; i <= n; ++i) {
long long x = rnd() % umax + 1;
kdl.insert(miaow(i, i, x));
}
}
void xw() {
while (m) {
--m;
int op = rnd() % 4 + 1, l = rnd() % n + 1, r = rnd() % n + 1;
if (l > r) swap(l, r);
long long x, y, ans;
if (op == 3)
x = (rnd() % (r - l + 1)) + 1;
else
x = (rnd() % umax) + 1;
if (op == 4) y = rnd() % umax + 1;
switch (op) {
case 1:
add(l, r, x);
break;
case 2:
xg(l, r, x);
break;
case 3:
ans = pm(l, r, x);
write(ans), putchar('\n');
break;
case 4:
ans = cf(l, r, x, y);
write(ans), putchar('\n');
break;
}
}
}
int main() {
csh();
xw();
return 0;
}
| 18 |
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
#define ios ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define f(i,x,n) for(int i=x;i<n;i++)
#define all(c) (c).begin(),(c).end()
#define ff first
#define ss second
#define pii pair<int,int>
#define pip pair<int,pii>
#define pb push_back
#define PI 3.14159265358979323846264
#define ld long double
#define deb(x) cerr << "[" << #x << " " << x << "]" << endl;
const int N=1e5+9;
const int mod=1e9+7;
int32_t main(){
ios;
#ifndef ONLINE_JUDGE
freopen("input.txt","r", stdin);
freopen("output.txt","w", stdout);
#endif
int t,n,k,in;
string a;
cin>>t;
while(t--){
cin>>n;
cin>>a;
string b="1";
for(int i=1;i<n;i++){
if('1'+a[i] != a[i-1]+b[i-1]){
b+="1";
}
else b+="0";
}
cout<<b<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 2;
int N, M;
long long k;
int par[MX], sz[MX];
long long n, c;
int arr[1001][1001], R[1001][1001], ans[1001][1100];
vector<pair<int, pair<int, int> > > v;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
bool valid(int x, int y) { return min(x, y) >= 0 && x < N && y < M; }
int f(int x) {
if (x == par[x]) return x;
return par[x] = f(par[x]);
}
void un(int x, int y) {
x = f(x);
y = f(y);
if (x == y) return;
sz[x] += sz[y];
par[y] = x;
}
void flood(int x, int y, int val) {
if (c == 0) return;
if (ans[x][y]) return;
ans[x][y] = n;
c--;
for (int d = 0; d < 4; d++) {
int xx = x + dx[d], yy = y + dy[d];
if (!valid(xx, yy)) continue;
if (arr[xx][yy] >= val) {
flood(xx, yy, val);
}
}
}
void print() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cout << ans[i][j] << " ";
}
cout << "\n";
}
}
void solve() {
memset(ans, 0, sizeof ans);
scanf("%d%d", &N, &M);
cin >> k;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
scanf("%d", &arr[i][j]);
v.push_back(make_pair(-arr[i][j], make_pair(i, j)));
}
}
for (int i = 0; i < M * N; i++) par[i] = i, sz[i] = 1;
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
v[i].first = -v[i].first;
int I = v[i].second.first, J = v[i].second.second;
for (int d = 0; d < 4; d++) {
int II = I + dx[d], JJ = J + dy[d];
if (!valid(II, JJ)) continue;
if (arr[I][J] <= arr[II][JJ]) {
un(I * M + J, II * M + JJ);
}
}
R[I][J] = sz[f(I * M + J)];
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (k % arr[i][j]) continue;
if (k / arr[i][j] <= R[i][j]) {
cout << "YES\n";
c = k / arr[i][j];
n = arr[i][j];
flood(i, j, arr[i][j]);
print();
return;
}
}
}
cout << "NO\n";
}
int main() {
int T = 1;
while (T--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int k;
long long int go(long long int i) { return i * (i - 1) / 2; }
int main() {
scanf("%lld", &k);
if (k == 0) putchar('a');
for (char a = 'a'; a <= 'z' && k; a++) {
int i = 1;
while (go(i + 1) <= k) i++;
k -= go(i);
for (int j = 0; j < i; j++) putchar(a);
}
putchar('\n');
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<int> s[100010];
set<int>::iterator it1, k;
set<int>::iterator it2;
pair<int, int> a[100010];
int ned[100010];
int tec[100010];
struct P {
int x1, x2, x3;
};
vector<P> ans;
int main() {
ios_base::sync_with_stdio(0);
int n, m, sum = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int l;
cin >> l;
s[i].insert(l);
}
tec[i] = s[i].size();
sum += k;
a[i] = make_pair(k, i);
}
sort(a + 1, a + n + 1);
for (int i = n; i >= 1; i--) {
int k = (sum) / n;
if (sum % n != 0) {
sum--;
k++;
}
ned[a[i].second] = k;
}
int l = 1, r = n;
while (1) {
while (r >= 1 && ned[a[r].second] == tec[a[r].second]) r--;
while (l <= n && ned[a[l].second] == tec[a[l].second]) l++;
if (r - l < 1) break;
it1 = s[a[l].second].begin();
it2 = s[a[r].second].begin();
while (1) {
if (it1 == s[a[l].second].end() && it2 == s[a[r].second].end()) break;
int fl = 0;
while (it1 != s[a[l].second].end() && (*it1) < (*it2)) it1++;
if (it1 == s[a[l].second].end() || (*it1) > (*it2)) {
ans.push_back({a[r].second, a[l].second, *it2});
s[a[l].second].insert(*it2);
k = it2;
it2++;
s[a[r].second].erase(k);
tec[a[r].second]--;
tec[a[l].second]++;
fl = 1;
} else {
it2++;
}
if (ned[a[r].second] == tec[a[r].second] ||
ned[a[l].second] == tec[a[l].second])
break;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].x1 << ' ' << ans[i].x2 << ' ' << ans[i].x3 << endl;
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
const int N = 55;
const int P = 1e9 + 7;
int F[N][N][N][N][2];
int main() {
function<LL(int, int)> com = [&](int n, int k) {
static vector<vector<LL>> C(N, vector<LL>(N, -1));
if (C[n][k] != -1) return C[n][k];
if (k * 2 > n) return com(n, n - k);
if (k == 0) return C[n][k] = 1LL;
return C[n][k] = com(n - 1, k) + com(n - 1, k - 1);
};
memset(F, -1, sizeof F);
int n, p;
scanf("%d%d", &n, &p);
vector<int> C(n + 1);
for (int i = (1); i <= (n); ++i) scanf("%d", &C[i]);
using State = array<int, 5>;
queue<State> Q;
Q.push({0, 0, 0, 0, 0});
LL ans = 0;
F[0][0][0][0][0] = 1;
while (!Q.empty()) {
State u = Q.front();
Q.pop();
int& obj = F[u[0]][u[1]][u[2]][u[3]][u[4]];
int tot = u[0] + u[1] + u[2] + u[3];
if (tot == n) {
if (u[4] == p) ans = (ans + obj) % P;
continue;
}
auto trans = [&](int d) {
int same = u[d] + u[d + 2];
int odd = u[(d ^ 1) + 2];
int even = u[d ^ 1];
auto inner = [&](bool flag) {
auto v = u;
v[4] ^= 1;
if (flag)
v[d + 2]++;
else
v[d]++;
if (flag) v[4] ^= 1;
int& nxt = F[v[0]][v[1]][v[2]][v[3]][v[4]];
if (nxt == -1) {
nxt = 0;
Q.push(v);
}
int k = (1LL << (same + odd)) % P;
int a = 0;
for (int i = flag; i <= even; i += 2) {
a = (a + com(even, i) % P) % P;
}
nxt = (nxt + 1LL * obj * k % P * a % P) % P;
};
inner(true);
inner(false);
};
if (C[tot + 1] == 0)
trans(0);
else if (C[tot + 1] == 1)
trans(1);
else {
trans(0);
trans(1);
}
}
cout << ans << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int a[150][150];
int cnt[10];
int n;
int getscore(int id, bool flag, int s) {
if (a[flag][id] == -1) return 0;
int sum;
if (a[0][id] == -1 || a[1][id] == -1 || a[0][id] < a[1][id])
sum = cnt[id];
else
sum = cnt[id] + s;
int score = 500;
for (int i = 2; i <= 32; i *= 2) {
if (sum * i > n + s)
break;
else
score += 500;
}
return score * (250.0 - a[flag][id]) / 250.0;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 5; ++j) {
cin >> a[i][j];
if (a[i][j] != -1) cnt[j]++;
}
for (int i = 0; i < 50000; ++i) {
int a1 = 0, a2 = 0;
for (int j = 0; j < 5; ++j) a1 += getscore(j, 0, i);
for (int j = 0; j < 5; ++j) a2 += getscore(j, 1, i);
if (a1 > a2) {
cout << i << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int mod = 1e9 + 7;
int n;
struct Edge {
int from, to, next;
} edge[200100 << 1];
int head[200100], num_edge;
inline void add_Edge(int from, int to) {
int t = ++num_edge;
edge[t].from = from;
edge[t].to = to;
edge[t].next = head[from];
head[from] = t;
}
long long dp[200100], pre[200100], suf[200100], ans[200100];
inline void dfs(int now, int comfrom) {
dp[now] = 1;
for (int i = head[now]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (to == comfrom) continue;
dfs(to, now);
dp[now] = dp[now] * (dp[to] + 1) % mod;
}
}
int fa[200100];
inline void bfs() {
queue<int> q;
q.push(1);
fa[1] = 0;
ans[1] = dp[1];
dp[1] = 0;
vector<int> son;
while (!q.empty()) {
int now = q.front();
q.pop();
son.clear();
for (int i = head[now]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (fa[now] == to) continue;
fa[to] = now;
son.push_back(to);
}
int len = (int)son.size();
long long nowv = 1;
for (int i = 0; i < len; i++) {
pre[i] = nowv;
nowv = nowv * (dp[son[i]] + 1) % mod;
}
nowv = 1;
for (int i = len - 1; i >= 0; i--) {
suf[i] = nowv;
nowv = nowv * (dp[son[i]] + 1) % mod;
}
int t = 0;
for (int i = head[now]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (fa[now] == to) continue;
long long nowv = pre[t] * suf[t] % mod;
nowv = nowv * (dp[now] + 1) % mod;
ans[to] = dp[to] * (nowv + 1) % mod;
q.push(to);
t++;
dp[to] = nowv;
}
}
}
int main() {
n = read();
num_edge = 0;
for (int i = 1; i <= n; i++) {
head[i] = -1;
}
for (int i = 2; i <= n; i++) {
int p = read();
add_Edge(p, i);
add_Edge(i, p);
}
dfs(1, 0);
bfs();
for (int i = 1; i <= n; i++) {
if (i != 1) printf(" ");
printf("%d", (int)ans[i]);
}
printf("\n");
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, temp, max = 0;
int a[51], b[51];
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (i = 0; i < m; i++) cin >> b[i];
int count = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (b[i] % a[j] == 0) {
temp = b[i] / a[j];
if (temp > max) max = temp;
break;
}
}
}
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
if (b[i] % a[j] == 0) {
temp = b[i] / a[j];
if (temp == max) count++;
break;
}
}
}
cout << count;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
long long val[17][17];
void init() {
for (int i = 0; i < 17; i++) {
for (int j = 0; j < 17; j++) {
val[i][j] = 0;
}
val[i][i] = 1;
}
}
Matrix operator*(const Matrix &a) const {
Matrix ans;
for (int i = 0; i < 17; i++) {
for (int j = 0; j < 17; j++) {
ans.val[i][j] = 0;
}
}
for (int i = 0; i < 17; i++) {
for (int j = 0; j < 17; j++) {
for (int k = 0; k < 17; k++) {
ans.val[i][j] += val[i][k] * a.val[k][j] % 1000000007;
}
ans.val[i][j] %= 1000000007;
}
}
return ans;
}
};
Matrix pow(Matrix a, long long b) {
Matrix ans, base = a;
ans.init();
while (b) {
if (b & 1) {
ans = ans * base;
}
base = base * base;
b >>= 1;
}
return ans;
}
int n;
long long k, ans[17], now[17];
int main() {
scanf("%d%I64d", &n, &k);
ans[0] = 1;
for (int t = 1; t <= n; t++) {
long long a, b;
int y;
scanf("%I64d%I64d%d", &a, &b, &y);
Matrix x;
for (int j = 0; j < 17; j++) {
for (int l = 0; l < 17; l++) {
x.val[l][j] = 0;
}
}
for (int j = 0; j <= y; j++) {
x.val[j][j] = 1;
if (j > 0) x.val[j][j - 1] = 1;
if (j < y) x.val[j][j + 1] = 1;
}
if (b > k) b = k;
Matrix c = pow(x, b - a);
memset(now, 0, sizeof(now));
for (int i = 0; i < 17; i++) {
for (int j = 0; j < 17; j++) {
now[i] += ans[j] * c.val[i][j] % 1000000007;
}
}
for (int i = 0; i < 17; i++) ans[i] = now[i] % 1000000007;
}
printf("%I64d\n", ans[0]);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6005;
int a[MAXN];
bool isprime(int n) {
int len = sqrt(n * 1.0);
for (int i = 2; i <= len; i++)
if (n % i == 0) return false;
return true;
}
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) a[i] = 1;
int m = (n + 1) * n / 2;
if (!isprime(m)) {
if (m % 2 == 0) {
int p = -1;
for (int i = 2; i <= n; i++)
if (isprime(i) && isprime(m - i)) {
p = i;
a[i] = 2;
break;
}
} else {
if (isprime(m - 2)) {
a[2] = 2;
} else {
a[3] = 2;
m -= 3;
for (int i = 2; i <= n; i++)
if (isprime(i) && isprime(m - i)) {
a[i] = 3;
break;
}
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int inf = 2e9;
char ma[maxn << 1];
int mp[maxn << 1];
inline void manacher(string &s, int len) {
int p = 0, r = 0, mid = 0;
ma[p++] = '$', ma[p++] = '#';
for (int i = 0; i < len; i++) ma[p++] = s[i], ma[p++] = '#';
for (int i = 0; i < p; i++) {
mp[i] = r > i ? min(mp[(mid << 1) - i], r - i) : 1;
if (i + mp)
while (ma[i + mp[i]] == ma[i - mp[i]]) mp[i]++;
if (i + mp[i] > r) r = i + mp[i], mid = i;
}
}
inline void init(int len) {
for (int i = 0; i < (len + 1) << 1; i++) {
mp[i] = 0;
ma[i] = '*';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int len = s.size();
int ans = 0;
for (int i = 0; i < len / 2; i++) {
if (s[i] == s[len - i - 1])
++ans;
else
break;
}
if (ans == len / 2) {
cout << s << '\n';
continue;
}
string m = "";
for (int i = ans; i < len - ans; ++i) m += s[i];
len = m.size();
int x = 0, y = 0;
manacher(m, len);
for (int i = 0; i < (len + 1) << 1; i++) {
if (i - mp[i] == 0) x = max(x, mp[i] - 1);
}
init(len);
reverse(m.begin(), m.end());
manacher(m, len);
for (int i = 0; i < (len + 1) << 1; i++) {
if (i - mp[i] == 0) y = max(y, mp[i] - 1);
}
init(len);
for (int i = 0; i < ans; i++) cout << s[i];
if (x > y) {
reverse(m.begin(), m.end());
for (int i = 0; i < x; i++) cout << m[i];
} else {
for (int i = 0; i < y; i++) cout << m[i];
}
for (int i = ans - 1; i >= 0; --i) cout << s[i];
cout << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void file() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
file();
long long testCases = 1;
while (testCases--) {
long long n, p;
cin >> n >> p;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
long long a = v.front(), b = v.back() - 1;
vector<long long> ans;
for (long long i = a; i <= b; i++) {
long long cnt = 1;
for (long long j = 0; j <= n - 1; j++) {
auto it = upper_bound(v.begin(), v.end(), i + j) - v.begin();
cnt *= (it - j);
cnt %= p;
}
if (cnt % p) ans.push_back(i);
}
cout << ans.size() << "\n";
for (auto it : ans) {
cout << it << ' ';
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int t = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) t++;
}
cout << t << endl;
if (n == 1) {
cout << 1;
} else {
for (int i = 1; i < n; i++) {
if (a[i] == 1) cout << a[i - 1] << " ";
}
cout << a[n - 1];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
int m;
cin >> m;
int ma = -1;
for (int i = 0; i < m; i++) {
int c;
cin >> c;
ma = max(c, ma);
}
v.push_back(make_pair(ma, m));
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
long long int ans = 0;
for (int i = 1; i < v.size(); i++) {
long long int dif = v[0].first - v[i].first;
long long int count = v[i].second;
ans += dif * count;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int s, n;
cin >> s >> n;
vector<pair<int, int> > ve;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
ve.push_back(make_pair(a, b));
}
sort(ve.begin(), ve.end());
int flag = 1;
for (int i = 0; i < n; i++) {
if (s <= ve[i].first) {
flag = 0;
break;
} else {
s += ve[i].second;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int dp[200005], leap[200005];
queue<int> p;
int main() {
int i, j, m, n, ans, temp, pre;
memset(leap, 0, sizeof(leap));
cin >> n >> m;
if (m > n)
pre = m;
else
pre = n;
pre = pre * 2;
for (i = 0; i <= pre; i++) dp[i] = 11000;
dp[n] = 0;
p.push(n);
leap[n] = 1;
while (p.size()) {
temp = p.front();
if (temp >= 2) {
dp[temp - 1] = min(dp[temp - 1], dp[temp] + 1);
if (!leap[temp - 1]) {
p.push(temp - 1);
leap[temp - 1] = 1;
}
}
if (temp * 2 <= 200005) {
dp[temp * 2] = min(dp[temp * 2], dp[temp] + 1);
if (!leap[temp * 2]) {
p.push(temp * 2);
leap[temp * 2] = 1;
}
}
p.pop();
}
cout << dp[m] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct kom {
string n;
int x;
int x1;
int x2;
};
bool cmp(kom a1, kom a2) {
if (a1.x != a2.x)
return a1.x > a2.x;
else if (a1.x1 != a2.x1)
return a1.x1 > a2.x1;
else
return a1.x2 > a2.x2;
}
kom a[51];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].n;
a[i].x = 0;
}
for (int j = 1; j <= n * (n - 1) / 2; j++) {
string s1, s2;
int k1, k2, n1 = 0, n2 = 0;
char c1, c2;
cin >> s1 >> k1 >> c1 >> k2;
int k3 = s1.find('-');
s2 = s1;
s1.erase(k3, s1.size() - k3);
s2.erase(0, k3 + 1);
if (k1 > k2) {
n1 = 3;
n2 = 0;
}
if (k1 < k2) {
n1 = 0;
n2 = 3;
}
if (k1 == k2) {
n1 = 1;
n2 = 1;
}
for (int i = 0; i < n; i++) {
if (a[i].n == s1) {
a[i].x += n1;
a[i].x1 += (k1 - k2);
a[i].x2 += k1;
}
if (a[i].n == s2) {
a[i].x += n2;
a[i].x1 += (k2 - k1);
a[i].x2 += k2;
}
}
}
sort(a, a + n, cmp);
string w[51];
for (int i = 0; i < n / 2; i++) w[i] = a[i].n;
sort(w, w + n / 2);
for (int i = 0; i < n / 2; i++) cout << w[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
const int Mod = 1e9 + 7;
int n, m;
int fa[N], sz[N], id[N];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
char S[N][N];
int G[N], dp[1 << 23], coe[1 << 23];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", S[i] + 1), fa[i] = i, sz[i] = 1;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (S[i][j] == 'A') {
int u = find(i), v = find(j);
if (u ^ v) fa[u] = v, sz[v] += sz[u];
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (S[i][j] == 'X' && find(i) == find(j)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++)
if (fa[i] == i && sz[i] > 1) id[i] = ++m;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (S[i][j] == 'X') {
int u = id[find(i)], v = id[find(j)];
if (u && v) G[u] |= 1 << (v - 1), G[v] |= 1 << (u - 1);
}
for (int i = 1; i <= m; i++) G[i] |= 1 << (i - 1);
if (!m) {
printf("%d\n", n - 1);
return 0;
}
dp[0] = 1;
for (int i = 0; i <= (1 << m) - 1; i++) {
for (int j = 0; j <= m - 1; j++)
if (i & (1 << j)) {
dp[i] = dp[i ^ (1 << j)] + dp[i ^ (i & G[j + 1])];
break;
}
coe[i] = (m - __builtin_popcount(i)) & 1 ? Mod - 1 : 1;
}
int ans = n;
for (int i = 1; i <= m; i++) {
int sum = 0;
for (int j = 0; j <= (1 << m) - 1; j++) {
coe[j] = 1ll * coe[j] * dp[j] % Mod;
sum = (sum + coe[j]) % Mod;
}
if (sum) {
printf("%d\n", ans);
return 0;
}
++ans;
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.precision(10);
cout << fixed;
int N, A, D;
cin >> N >> A >> D;
double last = 0.0;
for (int i = 0; i < N; ++i) {
int t, v;
cin >> t >> v;
double cur;
double L = 0.5 * v * v / A;
double T = 1.0 * v / A;
if (L < D) {
cur = t + T + (D - L) / v;
} else {
cur = t + sqrt(2.0 * D / A);
}
last = max(last, cur);
cout << last << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int ans(int a, char ch) {
int mxlen = a;
int done = 0;
int pnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] != ch) done++;
while (done > a) {
if (s[pnt] != ch) done--;
pnt++;
}
mxlen = max(mxlen, i - pnt + 1);
}
return mxlen;
}
int main() {
int q;
cin >> n >> s >> q;
int a;
char ch;
while (q--) {
cin >> a >> ch;
cout << ans(a, ch) << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
bool f = true;
for (int i = 0; i < 8; i++) {
cin >> str;
for (int j = 1; j < str.length(); j++) {
if (str[j] == str[j - 1]) {
f = false;
}
}
}
if (f)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
const long long INF = 1e9 + 7;
int n, m, a[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
int ans1 = 0, ans2 = 0;
ans2 = *max_element(a + 1, a + n + 1) + m;
while (m) {
int pos = min_element(a + 1, a + n + 1) - a;
a[pos]++;
m--;
}
ans1 = *max_element(a + 1, a + n + 1);
printf("%d %d\n", ans1, ans2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 35;
int main() {
int n, m, x, i, shift[1000][5], flag1, q, ind, j, i2, i1;
char a[MaxN][MaxN], obr;
int f[55];
for (i = 0; i < 55; i++) {
f[i] = -1;
}
ind = 0;
cin >> n >> m >> x;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == 'S') {
ind++;
shift[ind][1] = i;
shift[ind][2] = j;
}
}
}
for (i1 = 0; i1 < 26; i1++) {
flag1 = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j] == ((char)'a' + i1)) {
f[i1] = 0;
for (i2 = 1; i2 <= ind; i2++) {
if ((i - shift[i2][1]) * (i - shift[i2][1]) +
(j - shift[i2][2]) * (j - shift[i2][2]) <=
x * x) {
flag1 = 1;
}
}
}
}
}
if (f[i1] == 0) {
if (flag1) {
f[i1 + 26] = 0;
} else {
if (ind > 0) {
f[i1 + 26] = 1;
}
}
}
}
cin >> q;
int ans = 0;
for (i = 0; i < q; i++) {
cin >> obr;
if (((int)obr >= (int)'A') && ((int)obr <= 'Z')) {
obr = (int)obr + ((int)'a' - (int)'A');
if (f[(int)obr - (int)'a' + 26] == -1) {
cout << -1;
return 0;
}
if (f[(int)obr - (int)'a' + 26] == 1) {
ans++;
}
} else {
if (f[(int)obr - (int)'a'] == -1) {
cout << -1;
return 0;
}
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
int n, m;
cin >> n >> m;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
int last = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
int temp = last;
if (i % 2 == 0) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'W' || (i + 1 < n && s[i + 1][j] == 'W')) {
temp = j;
}
}
} else {
for (int j = m - 1; j >= 0; j--) {
if (s[i][j] == 'W' || (i + 1 < n && s[i + 1][j] == 'W')) {
temp = j;
}
}
}
ans += abs(temp - last);
last = temp;
}
int extra = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'W') {
extra = i;
break;
}
}
if (extra) break;
}
ans += extra;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAX = 1020;
int an[MAX];
int dp1[MAX], dp2[MAX][MAX];
int s1[MAX], s2[MAX][MAX];
int sum[MAX][MAX];
void print2(int n, int i);
void print1(int n) {
if (n == 0) return;
int j = s1[n];
print2(n - 1, j);
printf("%d %d\n", j, n);
assert(j != n);
}
void print2(int n, int i) {
assert(n >= 1);
if (n == 1) return;
if (i % 2 == 1) {
print1(i - 1);
int nxt = i + 1;
for (; nxt < n; nxt += 2) printf("%d %d\n", nxt, nxt + 1);
} else {
print2(i - 1, s2[n][i]);
int nxt = i + 1;
printf("%d %d\n", s2[n][i], nxt);
nxt++;
for (; nxt < n; nxt += 2) printf("%d %d\n", nxt, nxt + 1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &an[i]);
}
for (int i = 1; i <= n; i++) {
if (i % 2 == 0) {
for (int j = i + 1; j <= n; j += 2) {
if (j == i + 1)
sum[i][j] = max(an[i], an[j]);
else
sum[i][j] = sum[i][j - 2] + max(an[j], an[j - 1]);
}
}
}
for (int i = 1; i <= n; i++) {
if (i % 2 == 1) {
for (int j = 1; j <= i; j++) {
if (j % 2 == 1) {
int t1, t2 = 0;
if (j - 1 < 1)
t1 = 0;
else
t1 = dp1[j - 1];
int nxt = j + 1;
if (nxt < i) t2 += sum[nxt][i];
dp2[i][j] = t1 + t2 + an[j];
} else {
dp2[i][j] = INT_MAX;
auto &ele = dp2[i][j];
int opts = -1;
int prev = j - 1;
for (int s = 1; s <= prev; s++) {
int nxt = j + 1;
int t1 = dp2[prev][s] - an[s];
int t2 = 0;
t2 += max(an[s], an[nxt]);
nxt++;
if (nxt < i) t2 += sum[nxt][i];
int d = t1 + t2 + an[j];
if (d < ele) opts = s, ele = d;
}
s2[i][j] = opts;
}
}
} else {
auto &ele = dp1[i];
ele = INT_MAX;
int optj = -1;
for (int j = 1; j <= i - 1; j++) {
int d = dp2[i - 1][j] - an[j] + max(an[j], an[i]);
if (d < ele) optj = j, ele = d;
}
s1[i] = optj;
}
}
if (n % 2 == 0) {
printf("%d\n", dp1[n]);
print1(n);
} else {
int ans = INT_MAX;
int opti = -1;
for (int i = 1; i <= n; i++)
if (dp2[n][i] < ans) ans = dp2[n][i], opti = i;
printf("%d\n", ans);
print2(n, opti);
printf("%d\n", opti);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int MAX = 2e5 + 11;
using namespace std;
int N, A[MAX], P[MAX], SZ[MAX], R[MAX];
vector<pair<int, int>> E;
static int get(int x) { return P[x] = (x == P[x]) ? x : get(P[x]); }
static void add(int x, int y, int w) {
int a = get(x);
int b = get(y);
if (a == b) {
return;
}
if (SZ[a] > SZ[b]) {
swap(a, b);
}
P[a] = b;
SZ[b] += SZ[a];
R[SZ[b] - 1] = max(R[SZ[b] - 1], w);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i]);
}
for (int i = 0; i < N; ++i) {
SZ[i] = 1;
P[i] = i;
R[0] = max(R[0], A[i]);
}
for (int i = 0; i < N - 1; ++i) {
E.push_back({min(A[i], A[i + 1]), i});
}
sort(E.rbegin(), E.rend());
for (int i = 0; i < N - 1; ++i) {
add(E[i].second, E[i].second + 1, E[i].first);
}
for (int i = N - 2; i >= 0; i--) {
R[i] = max(R[i], R[i + 1]);
}
for (int i = 0; i < N; ++i) {
printf("%d ", R[i]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, m;
float sum = 0;
cin >> n >> m;
vector<float> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) sum += v[j] / (j + 1);
sum = round(sum);
if (int(sum) == m)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100, M = 1e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
inline long long read() {
char ch = getchar();
long long f = 1, x = 0;
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
struct node {
int x, y;
} nd[N];
vector<int> b;
int c[N], mxsiz;
bool vis[N];
bool cmp(node a, node b) {
if (a.y == b.y) return a.x < b.x;
return a.y > b.y;
}
void add(int x, int v) {
for (; x <= mxsiz; x += (x & -x)) c[x] += v;
}
int qry(int x) {
int res = 0;
for (; x > 0; x -= (x & -x)) res += c[x];
return res;
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
nd[i].x = read(), nd[i].y = read();
b.push_back(nd[i].x);
}
sort(nd + 1, nd + 1 + n, cmp);
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
mxsiz = b.size();
long long ans = 0;
for (int i = 1; i <= n; i++) {
int R;
if (i == n || nd[i + 1].y != nd[i].y)
R = mxsiz;
else
R = lower_bound(b.begin(), b.end(), nd[i + 1].x) - b.begin() + 1 - 1;
int L = lower_bound(b.begin(), b.end(), nd[i].x) - b.begin() + 1;
if (!vis[L]) {
add(L, 1);
vis[L] = 1;
}
ans += 1ll * qry(L) * (qry(R) - qry(L - 1));
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
map<int, int> mp;
int val;
int vect[100];
for (int i = 0; i < n; ++i) {
cin >> vect[i];
}
vector<int> v;
for (int i = 0; i < m; ++i) {
cin >> val;
mp[val] = 1;
}
for (int i = 0; i < n; ++i) {
if (mp[vect[i]] == 1) v.push_back(vect[i]);
}
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static const int L = 233333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
inline char readchar() {
char c = gc();
for (; !isalpha(c); c = gc())
;
return c;
}
template <class T>
inline bool read(T& x) {
bool flg = false;
char c = gc();
x = 0;
for (; !isdigit(c); c = gc()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = gc()) {
x = (x << 1) + (x << 3) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
const int maxn = 505;
const int inf = 0x3f3f3f3f;
int dp[maxn][maxn];
int c[maxn];
int main() {
int n;
read(n);
memset(dp, 0x3f, sizeof(dp));
for (int i = 1; i <= n; ++i) {
read(c[i]);
dp[i][i] = 1;
dp[i][i - 1] = 1;
}
for (int r = 1; r <= n; ++r) {
for (int l = r - 1; l; --l) {
if (c[l] == c[r]) {
dp[l][r] = dp[l + 1][r - 1];
}
for (int k = l; k < r; ++k) {
dp[l][r] = min(dp[l][k] + dp[k + 1][r], dp[l][r]);
}
}
}
printf("%d\n", dp[1][n]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int limit = 1e6;
long long int fab[limit + 1], inv[limit + 1];
long long int binpow(long long int n, long long int pow) {
long long int ans = 1ll;
while (pow) {
if (pow % 2 == 1) {
ans = (ans * n) % mod;
}
pow /= 2;
n = (n * n) % mod;
}
return ans;
}
long long int nCk(int n, int k) {
if (k < 0 || n < k) return 0ll;
return fab[n] * inv[k] % mod * inv[n - k] % mod;
}
int main() {
int n, m, k, i, j;
scanf("%d %d %d", &n, &m, &k);
fab[0] = 1ll;
for (i = 1; i <= limit; ++i) {
fab[i] = (1ll * fab[i - 1] * i) % mod;
}
inv[limit] = binpow(fab[limit], mod - 2);
for (i = limit - 1; i >= 0; i--) {
inv[i] = (inv[i + 1] * (i + 1)) % mod;
}
vector<pair<int, int> > block;
int x, y;
for (i = 0; i < k; ++i) {
scanf("%d %d", &x, &y);
x--;
y--;
block.push_back(pair<int, int>(x, y));
}
block.push_back(pair<int, int>(n - 1, m - 1));
sort(block.begin(), block.end());
long long int dp[k + 1];
dp[0] = nCk(block[0].first + block[0].second, block[0].first);
for (i = 1; i <= k; ++i) {
dp[i] = nCk(block[i].first + block[i].second, block[i].first);
for (j = 0; j < i; ++j) {
dp[i] = (dp[i] -
dp[j] *
nCk(block[i].first - block[j].first + block[i].second -
block[j].second,
block[i].first - block[j].first) %
mod +
mod) %
mod;
}
}
printf("%lld", dp[k]);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
const int inf = 1034567891;
const long long LL_INF = 1234567890123456789ll;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T>
T GCD(T a, T b) {
long long t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
string toString(T a) {
return to_string(a);
}
template <typename T>
void toInt(string s, T& x) {
stringstream str(s);
str >> x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, long long b) {
int x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
long long can = k * 1ll * (k - 1) / 2;
can *= 2;
if (can < n) {
cout << "NO" << '\n';
return 0;
}
cout << "YES" << '\n';
int a = 1, b = 2;
for (int i = 0; i < n - (n & 1); i += 2) {
cout << a << " " << b << '\n';
cout << b << " " << a << '\n';
b++;
if (b > k) {
a++;
b = a + 1;
}
}
if (n & 1) {
cout << a << " " << b << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> rats;
vector<string> child;
vector<string> man;
string s1, s2, cap;
for (int i = 0; i < n; i++) {
cin >> s1 >> s2;
if (s2 == "rat")
rats.push_back(s1);
else if (s2 == "woman" || s2 == "child")
child.push_back(s1);
else if (s2 == "man")
man.push_back(s1);
else
cap = s1;
}
for (int i = 0; i < rats.size(); i++) cout << rats[i] << endl;
for (int i = 0; i < child.size(); i++) cout << child[i] << endl;
for (int i = 0; i < man.size(); i++) cout << man[i] << endl;
cout << cap << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
// Hi
int main(){
ios::sync_with_stdio(0);cin.tie(0);
int tt;
cin>>tt;
while(tt--){
int n;
cin>>n;
vector<int> a(n);
for(auto &i:a)cin>>i;
if(is_sorted(a.begin(),a.end())){
cout << 0 << '\n';
}else if(a[0] == 1 || a[n-1] == n){
cout << 1 << '\n';
}else if(a[0] == n && a[n-1] == 1)cout << 3<<'\n';
else cout << 2 << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long a[N], b[N], ans = 0;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] *= (n + 1ll - i) * i;
}
for (int i = 1; i <= n; i++) cin >> b[i];
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
for (int i = 1; i <= n; i++) {
ans += (a[i] % 998244353 * b[n - i + 1]);
ans %= 998244353;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k;
long long int n, m;
map<long long int, long long int> mp;
cin >> n;
for (i = 0; i < n; i++) {
cin >> m;
mp[m]++;
}
long long int count = 0;
map<long long int, long long int>::iterator p = mp.begin();
while (p != mp.end()) {
if (p->first != 0 && p->second == 2)
count++;
else if (p->first != 0 && p->second > 2) {
cout << "-1";
return 0;
}
p++;
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long v[N], f[N][2], g[N][2];
int main() {
int n;
long long ans = 0;
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &v[i]);
for (int i = 2; i <= n; i++) {
if (v[i] >= 1)
f[i][0] = max(f[i - 1][0], f[i - 1][1]) + (v[i] % 2 ? v[i] : v[i] - 1);
if (v[i] >= 2) f[i][1] = f[i - 1][1] + (v[i] % 2 ? v[i] - 1 : v[i]);
}
for (int i = n - 1; i >= 1; i--) {
if (v[i + 1] >= 1)
g[i][0] = max(g[i + 1][0], g[i + 1][1]) +
(v[i + 1] % 2 ? v[i + 1] : v[i + 1] - 1);
if (v[i + 1] >= 2)
g[i][1] = g[i + 1][1] + (v[i + 1] % 2 ? v[i + 1] - 1 : v[i + 1]);
}
for (int i = 1; i <= n; i++)
ans = max(
ans, max(max(f[i][0] + g[i][1], f[i][1] + g[i][0]), f[i][1] + g[i][1]));
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long nums[200200], acum[200200];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lld", &nums[i]);
multiset<long long> aux;
for (int i = n - 1; i >= 0; i--) {
acum[i] = nums[i] + acum[i + 1];
aux.insert(acum[i]);
}
long long ans = 0, sum = 0;
for (int i = 0; i < n; i++) {
sum += nums[i];
aux.erase(aux.find(acum[i]));
if (aux.count(sum)) ans = max(ans, sum);
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, pr;
double p[100010];
int main() {
double ans = 0;
scanf("%I64d%I64d", &n, &pr);
for (int i = 0; i < n; i++) {
long long l, r;
scanf("%I64d%I64d", &l, &r);
p[i] =
((r - l + 1) - 1.0 * ((r / pr) - ((l - 1) / pr))) / (1.0 * (r - l + 1));
if (i) ans += (1.0 - p[i] * p[i - 1]);
}
ans += (1.0 - p[0] * p[n - 1]);
printf("%.10f\n", 2000 * ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
int n, d;
cin >> n >> d;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
while (a[i] > 0 && d >= i) {
d -= i;
a[i]--;
a[0]++;
}
}
cout << a[0] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tree[100005], Lson[100005 * 40], Rson[100005 * 40], Val[100005 * 40];
int g[100005], a[100005], tot;
void Insert(int &rt, int ot, int l, int r, int x, int v) {
rt = ++tot;
Lson[rt] = Lson[ot];
Rson[rt] = Rson[ot];
Val[rt] = Val[ot] + v;
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid)
Insert(Lson[rt], Lson[ot], l, mid, x, v);
else
Insert(Rson[rt], Rson[ot], mid + 1, r, x, v);
}
int query(int l, int r, int v, int p) {
if (l == r) return l;
int mid = (l + r) >> 1;
int res = Val[Lson[p]];
if (res >= v)
return query(l, mid, v, Lson[p]);
else
return query(mid + 1, r, v - res, Rson[p]);
}
int main() {
scanf("%d", &n);
for (int i = n; i >= 1; i--) {
scanf("%d", &a[i]);
if (g[a[i]]) {
int res = 0;
Insert(res, tree[i + 1], 1, n, g[a[i]], -1);
Insert(tree[i], res, 1, n, i, 1);
} else
Insert(tree[i], tree[i + 1], 1, n, i, 1);
g[a[i]] = i;
}
int x, ans;
int k = Val[tree[1]];
for (int i = 1; i <= k - 1; i++) {
x = 1, ans = 0;
while (x <= n) {
if (Val[tree[x]] <= i) {
ans++;
break;
}
ans++;
x = query(1, n, i + 1, tree[x]);
}
printf("%d ", ans);
}
for (int i = k; i <= n; i++) printf("1 ");
puts("");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int l, r;
cin >> l >> r;
cout << (l >= ((r + 2) / 2) ? "YES" : "NO") << '\n';
;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[21][21], i, j;
bool check(int j1, int j2) {
int i, j, k;
for (i = 1; i <= n; i++) {
swap(a[i][j1], a[i][j2]);
k = 0;
for (j = 1; j <= m; j++)
if (a[i][j] != j) k++;
swap(a[i][j1], a[i][j2]);
if (k != 2 && k != 0) return false;
}
return true;
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i][j];
for (int j1 = 1; j1 <= m; j1++)
for (int j2 = j1; j2 <= m; j2++)
if (check(j1, j2) == true) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
int m, s;
cin >> m >> s;
if (m > 1 && s == 0 || m * 9 < s) {
cout << "-1 -1" << endl;
return 0;
}
if (m == 1) {
cout << s << " " << s << endl;
return 0;
}
string temp;
int s2 = s, ct = 0;
while (s2 > 9) {
temp.push_back('9');
s2 -= 9;
ct++;
}
if (m - ct > 1) {
temp.push_back('1');
s2--;
}
if (s2 != 0) temp.push_back('0' + s2);
int sz = temp.size();
sort(temp.begin(), temp.end());
string tmp;
tmp.push_back(temp[0]);
for (int i = 0; i < m - sz; ++i) {
tmp.push_back('0');
}
for (int i = 1; i < temp.size(); ++i) {
tmp.push_back(temp[i]);
}
cout << tmp << " ";
string temp2;
int s3 = s, ct2 = 0;
while (s3 > 9) {
temp2.push_back('9');
s3 -= 9;
ct2++;
}
int p = m - ct2 - 1;
for (int i = 0; i < p; ++i) {
temp2.push_back('0');
}
temp2.push_back('0' + s3);
sort(temp2.rbegin(), temp2.rend());
cout << temp2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, p1[2010], p2[2010], inv1[2010], inv2[2010], sum;
vector<pair<int, int> > swps;
void slv(int posx, int y) {
if (p1[posx] == y) return;
int x = p1[posx], posy = inv1[y], tgtx = inv2[x];
if (tgtx < posx) {
slv(tgtx, x);
slv(posx, y);
return;
} else if (tgtx < posy) {
slv(tgtx, y);
slv(posx, y);
return;
}
p1[posx] = y, p1[posy] = x, inv1[y] = posx, inv1[x] = posy;
swps.push_back(make_pair(posx, posy));
sum += abs(posx - posy);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &p1[i]), inv1[p1[i]] = i;
for (int i = 1; i <= n; ++i) scanf("%d", &p2[i]), inv2[p2[i]] = i;
sum = 0;
for (int i = 1; i <= n; ++i) slv(i, p2[i]);
printf("%d\n%d\n", sum, (int)swps.size());
for (int i = 0; i < swps.size(); ++i)
printf("%d %d\n", swps[i].second, swps[i].first);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, a = 0, b = 0;
cin >> x;
string s, s1;
for (int i = 0; i < x; ++i) {
cin >> s >> s1;
if (s1 == "soft")
a++;
else
b++;
}
int i = 0, c;
if (b > a) swap(a, b);
while ((i * i / 2 < b) || ((i * i + 1) / 2) < a) i++;
cout << i << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long arr[100005], arrsort[100005];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
arrsort[i] = arr[i];
}
sort(arrsort, arrsort + n);
for (int i = 1; i < n; i++) {
arr[i] += arr[i - 1];
arrsort[i] += arrsort[i - 1];
}
int m;
cin >> m;
while (m--) {
int type, l, r;
cin >> type >> l >> r;
if (type == 1) {
if (l == 1) {
cout << arr[r - 1] << endl;
} else {
cout << arr[r - 1] - arr[l - 2] << endl;
}
} else {
if (l == 1) {
cout << arrsort[r - 1] << endl;
} else {
cout << arrsort[r - 1] - arrsort[l - 2] << endl;
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
int main() {
long long n;
cin >> n;
int t[n];
for (long long i = 0; i < (long long)n; i++) cin >> t[i];
vector<long long> v;
long long z = 0;
for (long long i = 0; i < (long long)n; i++) {
if (t[i] == t[i + 1])
z++;
else {
v.push_back(z + 1);
z = 0;
}
}
vector<long long> x;
for (long long i = 0; i < (long long)v.size() - 1; i++) {
x.push_back(min(v[i], v[i + 1]) * 2);
}
sort(x.begin(), x.end());
cout << x[x.size() - 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
struct ZAlgo {
string s;
int n;
vector<int> z;
void init(int _n) {
n = _n;
s = string(n, '?');
z = vector<int>(n, -1);
}
void calc() {
int l = 0, r = 0;
for (int i = (1); i < (n); ++i) {
if (i < r) {
int k = i - l;
if (z[k] < r - i) {
z[i] = z[k];
continue;
} else
l = i;
} else
l = r = i;
while (r < n && s[r] == s[r - l]) ++r;
z[i] = r - l;
}
}
};
struct RepeatRun {
int l, r, len;
RepeatRun(int l, int r, int len) : l(l), r(r), len(len) {}
};
struct RepeatFinder {
char *s;
int n;
ZAlgo ba, abrev;
vector<RepeatRun> runs;
void rec(int l, int r) {
if (l == r) return;
int m = l + (r - l) / 2;
rec(l, m);
rec(m + 1, r);
ba.n = 0;
for (int i = (m + 1); i <= (r); ++i) ba.s[ba.n++] = s[i];
ba.s[ba.n++] = '#';
for (int i = (l); i <= (m); ++i) ba.s[ba.n++] = s[i];
abrev.n = 0;
for (int i = m; i >= l; --i) abrev.s[abrev.n++] = s[i];
abrev.s[abrev.n++] = '#';
for (int i = r; i >= m + 1; --i) abrev.s[abrev.n++] = s[i];
ba.calc();
abrev.calc();
for (int i = (l); i <= (m); ++i) {
int k = m - i + 1, k1 = abrev.z[k], k2 = ba.z[r - m + 1 + i - l];
if (k1 + k2 >= k && k2 >= 1)
runs.push_back(RepeatRun(i - min(k - 1, k1), i - (k - k2), k));
}
for (int i = (m + 2); i <= (r); ++i) {
int k = i - m, k1 = ba.z[k], k2 = abrev.z[m - l + 1 + 1 + r - i];
if (k1 + k2 >= k && k2 >= 1 && k1 >= 1)
runs.push_back(
RepeatRun(m + 1 - min(k - 1, k2), m + 1 - max(k - k1, 1), k));
}
}
void init(char *_s) {
s = _s;
n = strlen(s);
ba.init(n + 1);
abrev.init(n + 1);
}
void calcruns() {
runs.clear();
rec(0, n - 1);
}
vector<int> calcminstart() {
vector<vector<int>> e(n + 1);
for (int i = (0); i < (((int)(runs).size())); ++i)
e[runs[i].l].push_back(runs[i].len),
e[runs[i].r + 1].push_back(-runs[i].len);
multiset<int> have;
vector<int> ret(n);
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (((int)(e[i]).size())); ++j) {
int x = e[i][j];
if (x > 0)
have.insert(x);
else
have.erase(have.find(-x));
}
ret[i] = ((int)(have).size()) == 0 ? 0 : *have.begin();
}
return ret;
}
vector<int> calcminend() {
vector<vector<int>> e(n + 1);
for (int i = (0); i < (((int)(runs).size())); ++i)
e[runs[i].l + 2 * runs[i].len - 1].push_back(runs[i].len),
e[runs[i].r + 2 * runs[i].len].push_back(-runs[i].len);
multiset<int> have;
vector<int> ret(n);
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (((int)(e[i]).size())); ++j) {
int x = e[i][j];
if (x > 0)
have.insert(x);
else
have.erase(have.find(-x));
}
ret[i] = ((int)(have).size()) == 0 ? 0 : *have.begin();
}
return ret;
}
};
struct RMQ {
int *a;
int n;
void init(int *_a, int _n) {
a = _a;
n = _n;
}
vector<int> lg;
vector<vector<int>> rmq;
void calc() {
lg = vector<int>(n + 1);
lg[1] = 0;
for (int i = (1); i <= (n); ++i) {
lg[i] = lg[i - 1];
while ((2 << lg[i]) <= i) ++lg[i];
}
rmq = vector<vector<int>>(n, vector<int>(lg[n] + 1));
for (int i = (0); i < (n); ++i) rmq[i][0] = a[i];
for (int k = (0); k < (lg[n]); ++k)
for (int i = (0); i < (n); ++i)
if (i + (1 << k) < n)
rmq[i][k + 1] = min(rmq[i][k], rmq[i + (1 << k)][k]);
else
rmq[i][k + 1] = rmq[i][k];
}
int query(int l, int r) {
int k = lg[r - l + 1];
return min(rmq[l][k], rmq[r - (1 << k) + 1][k]);
}
};
struct SuffixArray {
char *s;
int n;
void init(char *_s, bool cyclic) {
s = _s;
n = strlen(s) + (cyclic ? 0 : 1);
}
vector<int> sa, id, cnt, sa2, oid;
int nid;
void calcsuffixarray() {
sa = id = sa2 = oid = vector<int>(n);
nid = 256;
cnt = vector<int>(max(n, nid), 0);
for (int i = (0); i < (n); ++i) oid[i] = (int)s[i];
for (int i = (0); i < (n); ++i) ++cnt[oid[i]];
for (int i = (1); i < (nid); ++i) cnt[i] += cnt[i - 1];
for (int i = (0); i < (n); ++i) sa[--cnt[oid[i]]] = i;
nid = 0;
for (int i = (0); i < (n); ++i)
if (i == 0 || oid[sa[i]] != oid[sa[i - 1]])
id[sa[i]] = nid++;
else
id[sa[i]] = id[sa[i - 1]];
for (int step = 0; (1 << step) < n; ++step) {
for (int i = (0); i < (n); ++i) {
oid[i] = id[i], sa2[i] = sa[i] - (1 << step);
if (sa2[i] < 0) sa2[i] += n;
}
for (int i = (0); i < (nid); ++i) cnt[i] = 0;
for (int i = (0); i < (n); ++i) ++cnt[oid[sa2[i]]];
for (int i = (1); i < (nid); ++i) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; --i) sa[--cnt[oid[sa2[i]]]] = sa2[i];
nid = 0;
for (int i = (0); i < (n); ++i)
if (i == 0 || oid[sa[i]] != oid[sa[i - 1]] ||
oid[(sa[i] + (1 << step)) % n] !=
oid[(sa[i - 1] + (1 << step)) % n])
id[sa[i]] = nid++;
else
id[sa[i]] = id[sa[i - 1]];
}
}
vector<int> pos, lcp;
void calcadjacentlcp() {
pos = vector<int>(n);
for (int i = (0); i < (n); ++i) pos[sa[i]] = i;
lcp = vector<int>(n - 1);
int k = 0;
for (int i = (0); i < (n); ++i)
if (pos[i] != n - 1) {
while (i + k < n && sa[pos[i] + 1] + k < n &&
s[i + k] == s[sa[pos[i] + 1] + k])
++k;
lcp[pos[i]] = k;
k = max(0, k - 1);
}
}
RMQ rmq;
void preparegenerallcp() {
rmq.init(lcp.data(), n - 1);
rmq.calc();
}
int querylcp(int l, int r) {
l = pos[l], r = pos[r];
if (l > r) swap(l, r);
if (l == r) return n - l;
return rmq.query(l, r - 1);
}
};
const int MAXLEN = 200000;
const int MAXQ = 200000;
const int ALPH = 26;
int slen;
char s[MAXLEN + 1];
int nq;
int ql[MAXQ], qr[MAXQ], qans[MAXQ];
int charsum[MAXLEN + 1][ALPH];
RepeatFinder repeatfinder;
int firstrepeatends[MAXLEN];
int lastrepeatstarts[MAXLEN];
SuffixArray suffixarray;
int pmn[MAXLEN + 1];
RMQ nextrepeatends;
int sqrtslen;
void precalc() {
for (int k = (0); k < (ALPH); ++k) charsum[0][k] = 0;
for (int i = (0); i < (slen); ++i)
for (int k = (0); k < (ALPH); ++k)
charsum[i + 1][k] = charsum[i][k] + (s[i] == 'a' + k ? 1 : 0);
repeatfinder.init(s);
repeatfinder.calcruns();
vector<int> minstart = repeatfinder.calcminstart(),
minend = repeatfinder.calcminend();
for (int i = (0); i < (slen); ++i)
firstrepeatends[i] = minstart[i] == 0 ? slen : i + 2 * minstart[i] - 1;
for (int i = (0); i < (slen); ++i)
lastrepeatstarts[i] = minend[i] == 0 ? -1 : i - 2 * minend[i] + 1;
nextrepeatends.init(firstrepeatends, slen);
nextrepeatends.calc();
suffixarray.init(s, false);
suffixarray.calcsuffixarray();
suffixarray.calcadjacentlcp();
suffixarray.preparegenerallcp();
memset(pmn, -1, sizeof(pmn));
for (int i = (2); i <= (MAXLEN); ++i)
if (pmn[i] == -1)
for (int j = i; j <= MAXLEN; j += i)
if (pmn[j] == -1) pmn[j] = i;
sqrtslen = 1;
while (sqrtslen * sqrtslen <= slen) ++sqrtslen;
}
int countchar(int l, int r, char c) {
return charsum[r + 1][c - 'a'] - charsum[l][c - 'a'];
}
bool impossible(int l, int r) {
for (char c = 'a'; c <= 'z'; ++c)
if (countchar(l, r, c) >= 2) return false;
return true;
}
bool periodic(int l, int r) {
int len = r - l + 1, x = len;
while (x != 1) {
int p = pmn[x], repcnt = p, replen = len / repcnt;
if (suffixarray.querylcp(l, l + replen) >= len - replen) return true;
while (x % p == 0) x /= p;
}
return false;
}
bool startswithrepeat(int l, int r) { return firstrepeatends[l] <= r; }
bool endswithrepeat(int l, int r) { return lastrepeatstarts[r] >= l; }
bool hasborder(int l, int r) {
for (int len = (1); len < (sqrtslen); ++len)
if (len >= r - l + 1)
return false;
else if (suffixarray.querylcp(l, r - len + 1) >= len)
return true;
int lim = (slen - 1) / sqrtslen, lo = max(0, suffixarray.pos[l] - lim),
hi = min(slen, suffixarray.pos[l] + lim);
for (int idx = (lo); idx <= (hi); ++idx) {
int i = suffixarray.sa[idx];
if (i > l && i <= r && suffixarray.querylcp(l, i) >= r - i + 1) return true;
}
return false;
}
bool containschar(int l, int r, char c) { return countchar(l, r, c) >= 1; }
bool containsrepeat(int l, int r) { return nextrepeatends.query(l, r) <= r; }
int calc(int l, int r) {
if (impossible(l, r)) return -1;
if (periodic(l, r)) return 1;
if (startswithrepeat(l, r) || endswithrepeat(l, r) || hasborder(l, r))
return 2;
if (containschar(l + 1, r, s[l]) || containschar(l, r - 1, s[r]) ||
containsrepeat(l, r))
return 3;
return 4;
}
void solve() {
precalc();
for (int i = (0); i < (nq); ++i) qans[i] = calc(ql[i], qr[i]);
}
void run() {
scanf("%d", &slen);
scanf("%s", s);
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i)
scanf("%d%d", &ql[i], &qr[i]), --ql[i], --qr[i];
solve();
for (int i = (0); i < (nq); ++i) printf("%d\n", qans[i]);
}
int main() {
run();
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x, y, height = 0, wtf = 0, result = 0;
cin >> a >> b >> x >> y;
height = b + y;
wtf = a + 2;
result = (height + wtf) * 2;
cout << result << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
long long ans = 0;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i], a[i] = abs(a[i]);
sort(a.begin(), a.end());
int r = 0;
for (int l = 0; l < n; l++) {
while (a[r] * 2 >= a[l] && a[l] * 2 >= a[r] && r + 1 <= n) r++;
ans += r - l - 1;
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void no() {
cout << "NO";
exit(0);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n * 2);
for (int i = 0; i < n * 2; i++) {
char c;
cin >> c;
if (c == '+')
a[i] = -1;
else {
int x;
cin >> x;
a[i] = x;
}
}
reverse(a.begin(), a.end());
stack<int> st;
vector<int> res;
for (int i = 0; i < n * 2; i++) {
if (a[i] == -1) {
if (st.empty()) {
no();
} else {
res.push_back(st.top());
st.pop();
}
continue;
}
if (st.empty()) {
st.push(a[i]);
} else {
if (st.top() < a[i]) {
no();
}
st.push(a[i]);
}
}
reverse(res.begin(), res.end());
cout << "YES\n";
for (auto i : res) {
cout << i << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int IntMaxVal = (int)1e20;
int IntMinVal = (int)-1e20;
long long LongMaxVal = (long long)1e20;
long long LongMinVal = (long long)-1e20;
using namespace std;
template <typename T>
struct argument_type;
template <typename T, typename U>
struct argument_type<T(U)> {};
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& s) {
is >> s.first >> s.second;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < v.size(); i++) os << v[i] << ' ';
os << '\n';
;
return os;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& s, pair<T1, T2>& t) {
s << t.first << ' ' << t.second;
return s;
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
;
int m;
cin >> m;
;
int k;
cin >> k;
;
int f[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cin >> f[i][j];
}
int ans = IntMaxVal;
if (n <= k) {
for (int mask = 0; mask < 1 << n; ++mask) {
int res = 0;
vector<int> row(n);
for (int j = 0; j < n; ++j) row[j] = (mask & (1 << j)) ? 1 : 0;
for (int r2 = 0; r2 < m; ++r2) {
int match = 0;
for (int j = 0; j < n; ++j)
if (f[j][r2] == row[j]) match++;
res += min(match, n - match);
}
{ ans = min(ans, res); };
}
} else {
for (int r = 0; r < n; ++r) {
int res = 0;
for (int r2 = 0; r2 < n; ++r2) {
int match = 0;
for (int j = 0; j < m; ++j)
if (f[r2][j] == f[r][j]) match++;
res += min(match, m - match);
}
{ ans = min(ans, res); };
}
}
if (ans > k)
cout << -1;
else
cout << ans;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
struct Seg {
int Max, Lazy;
};
Seg A[(35000 + 2) << 3];
int n, k, a[(35000 + 2)], Pre[(35000 + 2)], g[(35000 + 2)],
f[(50 + 1)][(35000 + 2)];
void init() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
memset(g, 0, sizeof(g));
for (int i = 1; i <= n; ++i) Pre[i] = g[a[i]], g[a[i]] = i;
memset(f, 0, sizeof(f));
}
void Update(int rt) { A[rt].Max = max(A[rt << 1].Max, A[rt << 1 | 1].Max); }
void Push(int rt) {
int Val = A[rt].Lazy;
A[rt << 1].Max += Val;
A[rt << 1 | 1].Max += Val;
A[rt << 1].Lazy += Val;
A[rt << 1 | 1].Lazy += Val;
A[rt].Lazy = 0;
}
void Add(int l, int r, int rt, int ll, int rr) {
int mid = (l + r) >> 1;
Push(rt);
if (ll <= l && rr >= r) {
A[rt].Lazy++;
A[rt].Max++;
return;
}
if (ll <= mid) Add(l, mid, rt << 1, ll, rr);
if (rr > mid) Add(mid + 1, r, rt << 1 | 1, ll, rr);
Update(rt);
}
void Ins(int l, int r, int rt, int Pos, int Val) {
int mid = (l + r) >> 1;
Push(rt);
if (l == r) {
A[rt].Max = Val;
A[rt].Lazy = 0;
return;
}
if (Pos <= mid) Ins(l, mid, rt << 1, Pos, Val);
if (Pos > mid) Ins(mid + 1, r, rt << 1 | 1, Pos, Val);
Update(rt);
}
int Query(int l, int r, int rt, int ll, int rr) {
int mid = (l + r) >> 1;
Push(rt);
if (l <= ll && r >= rr) return A[rt].Max;
int M = 0;
if (ll <= mid) M = Query(l, mid, rt << 1, ll, rr);
if (rr > mid) M = max(M, Query(mid + 1, r, rt << 1 | 1, ll, rr));
Update(rt);
return M;
}
bool p[(35000 + 2)];
void DO_IT() {
memset(p, 0, sizeof(p));
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; ++i) {
f[1][i] = f[1][i - 1];
if (!p[a[i]]) f[1][i]++;
p[a[i]] = 1;
}
for (int t = 2; t <= k; ++t) {
memset(A, 0, sizeof(A));
for (int i = 1; i <= n; ++i) {
if (i > 1) Add(1, n, 1, max(Pre[i], 1), i - 1);
f[t][i] = max(f[t - 1][i], Query(1, n, 1, 1, i - 1));
Ins(1, n, 1, i, f[t - 1][i]);
}
}
}
int main() {
init();
DO_IT();
cout << f[k][n];
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long A = INT_MAX, B = INT_MAX, C = INT_MAX, AB = INT_MAX, AC = INT_MAX,
BC = INT_MAX, ABC = INT_MAX;
for (int i = 0; i < n; i++) {
long long c;
string s;
vector<bool> ma(3, false);
cin >> c >> s;
for (auto charac : s) {
ma[charac - 'A'] = true;
}
if (ma[0]) {
A = min(A, c);
}
if (ma[1]) {
B = min(B, c);
}
if (ma[2]) {
C = min(C, c);
}
if (ma[0] && ma[1]) {
AB = min(AB, c);
}
if (ma[0] && ma[2]) {
AC = min(AC, c);
}
if (ma[1] && ma[2]) {
BC = min(BC, c);
}
if (ma[0] && ma[1] && ma[2]) {
ABC = min(ABC, c);
}
}
long long res = INT_MAX;
res = min(res, ABC);
res = min(res, BC + A);
res = min(res, AC + B);
res = min(res, AB + C);
res = min(res, A + B + C);
cout << (res == INT_MAX ? -1 : res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
template <typename T>
using v = vector<T>;
using pi = pair<lli, lli>;
using vi = v<lli>;
using vvi = v<vi>;
using vp = v<pi>;
using vvp = v<vp>;
constexpr lli INF = numeric_limits<lli>::max();
void input() {}
template <typename T, typename... Ts>
void input(T &arg1, Ts &...args) {
cin >> arg1;
input(args...);
}
template <typename ST>
void output(ST &strm) {}
template <typename ST, typename T, typename... Ts>
void output(ST &strm, const T &arg1, const Ts &...args) {
strm << arg1 << " ";
output(strm, args...);
}
template <typename T, typename S>
void maxx(T &a, const S &b) {
a = a > b ? a : b;
}
template <typename T, typename S>
void minn(T &a, const S &b) {
a = a < b ? a : b;
}
void solve() {
lli n;
input(n);
lli m;
input(m);
if (n == 1 && m == 1) {
cout << "B\n";
return;
}
if (n == 1) {
cout << "BW";
for (int i = 0; i < (m - 2); i++) {
cout << "B";
}
cout << "\n";
return;
}
if (m == 1) {
cout << "B\nW\n";
for (int i = 0; i < (n - 2); i++) {
cout << "B\n";
}
return;
}
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
if (i == 0 && j == 0) {
cout << "W";
} else {
cout << "B";
}
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
lli tcn;
input(tcn);
for (int i = 0; i < (tcn); i++) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int tab[1234], kar[1234], c[1243], ans[1234];
void bsort(int *tab, int nt) {
int i, j, t;
for (i = 1; i < nt; i++)
for (j = 1; j < nt; j++)
if (c[tab[j]] < c[tab[j - 1]])
t = tab[j], tab[j] = tab[j - 1], tab[j - 1] = t;
}
int main(void) {
int i, j, n, k, t, nt, nk;
long long res;
while (scanf(" %d %d", &n, &k) != EOF) {
nt = nk = 0;
res = 0;
for (i = 0; i < n; i++) {
scanf("%d %d", &c[i], &t);
if (t == 1)
tab[nt++] = i;
else
kar[nk++] = i;
res += 2 * c[i];
}
bsort(tab, nt);
bsort(kar, nk);
for (i = 0; i < nt && i < k; i++) {
ans[i] = tab[nt - i - 1];
res -= c[tab[nt - i - 1]];
}
if (i == k) {
res += c[tab[nt - i]];
res -= min(c[tab[0]], c[kar[0]]);
printf("%I64d.%I64d\n", res / 2, (res % 2) * 5);
for (i = 0; i < k - 1; i++) printf("1 %d\n", ans[i] + 1);
printf("%d ", n - k + 1);
for (; i < nt; i++) printf("%d ", tab[nt - i - 1] + 1);
for (i = 0; i < nk; i++) printf("%d ", kar[i] + 1);
printf("\n");
} else {
printf("%I64d.%I64d\n", res / 2, (res % 2) * 5);
for (i = 0; i < nt; i++) printf("1 %d\n", ans[i] + 1);
for (j = 0; i < k - 1; i++, j++) printf("1 %d\n", kar[j] + 1);
printf("%d ", n - k + 1);
for (; j < nk; j++) printf("%d ", kar[j] + 1);
printf("\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int a[N];
int n, m, c;
bool win() {
if (!a[1]) return false;
for (int i = 2; i <= n; i++)
if (a[i] < a[i - 1] || !a[i]) return false;
return true;
}
int main() {
cin >> n >> m >> c;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
if (x <= c / 2) {
for (int i = 1; i <= n; i++) {
if (!a[i] || a[i] > x) {
cout << i << endl;
a[i] = x;
break;
}
}
} else {
for (int i = n; i > 0; i--)
if (!a[i] || a[i] < x) {
cout << i << endl;
a[i] = x;
break;
}
}
if (win()) break;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000];
int l[1000000];
int n, m;
int main() {
cin >> n >> m;
a[0] = 0;
l[0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
bool f = 1;
for (int i = 1; i <= n; i++) {
l[i] = l[i - 1] + f * (a[i] - a[i - 1]);
f = !f;
}
l[n + 1] = l[n] + f * (m - a[n]);
int ans = l[n + 1];
for (int i = 1; i <= n; i++) {
ans = max(ans, l[i] + m - a[i] - (l[n + 1] - l[i]) - 1);
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 20;
int a[N], dpL[N], dpR[N], n, sum;
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
iota(dpL, dpL + n, 0);
for (int i = 1; i < n; i++) {
int x = i - 1;
while (a[x] % a[i] == 0 && x >= 0) {
dpL[i] = dpL[x];
x = dpL[x] - 1;
}
}
iota(dpR, dpR + n, 0);
for (int i = n - 2; ~i; i--) {
int x = i + 1;
while (a[x] % a[i] == 0 && x < n) {
dpR[i] = dpR[x];
x = dpR[x] + 1;
}
}
for (int i = 0; i < n; i++) sum = max(dpR[i] - dpL[i], sum);
for (int i = 0; i < n; i++)
if (dpR[i] - dpL[i] == sum) ans.push_back(dpL[i] + 1);
sort(ans.begin(), ans.end());
ans.resize(unique(ans.begin(), ans.end()) - ans.begin());
cout << ans.size() << " " << sum << "\n";
for (auto i : ans) cout << i << " ";
return cout << "\n", 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int j = 0;
int n = s.length();
for (int i = 0; i < n; i++) {
if (s[i] <= j + 'a') {
s[i] = j + 'a';
j++;
}
if (j == 26) break;
}
if (j != 26)
cout << -1;
else
cout << s;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
cin >> n;
int ans = 0;
while (cin >> s) {
int cnt = 0;
for (int i = 0; i < s.size(); ++i)
if (isupper(s[i])) ++cnt;
ans = max(ans, cnt);
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[302][302], used[302][302];
queue<pair<int, int>> q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
bool ok = true;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if ((i == 0 && j == 0) || (i == 0 && j == m - 1) ||
(i == n - 1 && j == 0) || (i == n - 1 && j == m - 1)) {
if (a[i][j] > 2)
ok = false;
else
a[i][j] = 2;
continue;
}
if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
if (a[i][j] > 3)
ok = false;
else
a[i][j] = 3;
continue;
}
if (a[i][j] > 4) ok = false;
a[i][j] = 4;
}
if (ok == false)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long fast_pow(long long target, long long p);
int t, cot;
char a[105];
int flag[256];
int que[30];
int main() {
scanf("%d", &t);
while (t--) {
for (int i = 0; a[i]; i++) a[i] = 0;
cot = 0;
for (int i = 97; i < 123; i++) flag[i] = 0;
scanf("%s", a);
for (int i = 0; a[i]; i++) flag[a[i]]++;
for (int i = 97; i <= 122; i++)
if (flag[i]) que[cot++] = i;
if (cot == 2 && que[0] == que[1] - 1) {
printf("No answer\n");
continue;
}
if (cot == 3 && que[0] == que[1] - 1 && que[1] == que[2] - 1) {
printf("No answer\n");
continue;
}
if (cot < 3)
for (int j = 0; j < cot; j++)
for (int i = 0; i < flag[que[j]]; i++) printf("%c", que[j]);
if (cot == 3) {
if (que[0] == que[1] - 1) {
for (int i = 0; i < flag[que[0]]; i++) printf("%c", que[0]);
for (int i = 0; i < flag[que[2]]; i++) printf("%c", que[2]);
for (int i = 0; i < flag[que[1]]; i++) printf("%c", que[1]);
} else if (que[1] == que[2] - 1) {
for (int i = 0; i < flag[que[2]]; i++) printf("%c", que[2]);
for (int i = 0; i < flag[que[0]]; i++) printf("%c", que[0]);
for (int i = 0; i < flag[que[1]]; i++) printf("%c", que[1]);
} else {
for (int i = 0; i < flag[que[2]]; i++) printf("%c", que[2]);
for (int i = 0; i < flag[que[0]]; i++) printf("%c", que[0]);
for (int i = 0; i < flag[que[1]]; i++) printf("%c", que[1]);
}
}
if (cot > 3) {
if (cot % 2) {
for (int i = 0; i < 2 * cot; i += 2)
for (int j = 0; j < flag[que[i % cot]]; j++)
printf("%c", que[i % cot]);
} else {
for (int i = 0; i < cot; i += 2)
for (int j = 0; j < flag[que[(i + cot - 2) % cot]]; j++)
printf("%c", que[(i + cot - 2) % cot]);
for (int i = 1; i < cot; i += 2)
for (int j = 0; j < flag[que[(i + cot - 2) % cot]]; j++)
printf("%c", que[(i + cot - 2) % cot]);
}
}
printf("\n");
}
return 0;
}
long long fast_pow(long long target, long long p) {
long long a[50];
a[1] = target;
for (int i = 2; i < 50; i++) {
a[i] = a[i - 1] * a[i - 1];
a[i] %= 10000000007;
}
long long ans = 1;
for (int i = 1; p; i++) {
if (p % 2) ans = (ans * a[i]) % 10000000007;
p /= 2;
}
return ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = 1e18 + 10;
const int MAX = 1e6 + 10;
const int MAXP = 1e6;
long long n1, n2, n3, m1, m2, m3, s1, s2, s3, n, m, s;
int prime[MAX];
long long res;
vector<pair<int, int> > fn, fs;
vector<long long> ff;
void prime_sieve() {
for (int i = 2; i * i <= MAXP; i++)
if (!prime[i])
for (int j = i; j <= MAXP / i; j++)
if (!prime[i * j]) prime[i * j] = i;
for (int i = 2; i <= MAXP; i++)
if (!prime[i]) prime[i] = i;
}
vector<pair<int, int> > factor(long long x) {
vector<pair<int, int> > res;
while (x > 1) {
int p = prime[x], cnt = 0;
while (x % p == 0) {
cnt++;
x /= p;
}
res.push_back(make_pair(p, cnt));
}
return res;
}
vector<pair<int, int> > combine(vector<pair<int, int> > a,
const vector<pair<int, int> >& b) {
for (int i = 0; i < (int)b.size(); i++) a.push_back(b[i]);
sort(a.begin(), a.end());
if (a.size() == 0) return a;
int j = 1;
for (int i = 1; i < (int)a.size(); i++) {
if (a[i].first == a[j - 1].first)
a[j - 1].second += a[i].second;
else
a[j++] = a[i];
}
a.resize(j);
return a;
}
long long power(long long x, long long n) {
if (n == 0) return 1;
long long tmp = power(x, n / 2);
tmp = tmp * tmp;
if (n & 1) tmp *= x;
return tmp;
}
vector<long long> filter(const vector<pair<int, int> >& a,
const vector<pair<int, int> >& b) {
vector<long long> res;
int i = 0, j = 0;
while (i < (int)a.size() && j < (int)b.size()) {
if (a[i].first == b[j].first) {
if (a[i].second > b[j].second) {
res.push_back(power(a[i].first, b[j].second + 1));
}
i++;
j++;
} else if (a[i].first < b[j].first) {
res.push_back(a[i].first);
i++;
} else
j++;
}
for (; i < (int)a.size(); i++) res.push_back(a[i].first);
return res;
}
bool ison(int i, int x) { return (x >> i) & 1; }
void attempt(int p, long long x) {
if (p == (int)fs.size()) {
res += (x <= n);
return;
}
long long power = 1;
for (int i = 0; i <= fs[p].second; i++) {
attempt(p + 1, x * power);
power *= fs[p].first;
}
}
void process() {
prime_sieve();
int t;
cin >> t;
while (t--) {
cin >> n1 >> n2 >> n3;
n = n1 * n2 * n3;
cin >> m1 >> m2 >> m3;
m = m1 * m2 * m3;
cin >> s1 >> s2 >> s3;
s = s1 * s2 * s3;
fn = combine(factor(n1), combine(factor(n2), factor(n3)));
fs = combine(factor(2),
combine(factor(s1), combine(factor(s2), factor(s3))));
ff = filter(fn, fs);
int nff = ff.size();
res = 0;
for (int ms = 1; ms < (1 << nff); ms++) {
long long x = 1;
int cnt = 0;
for (int i = 0; i < nff; i++)
if (ison(i, ms)) {
x *= ff[i];
cnt++;
}
res += ((cnt & 1) ? 1 : -1) * (m / x);
}
res = m - res;
attempt(0, 1);
cout << res << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
process();
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 7, M = 1e7, OO = 0x3f3f3f3f;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, i, counter = 0, even_at_odd = 0, odd_at_odd = 0, even = 0, odd = 0,
even_at_even = 0, odd_at_even = 0;
string s;
scanf("%d", &n);
cin >> s;
for (i = 0; i < n; ++i) {
if ((s[i] - '0') % 2 == 0) {
even++;
if (i % 2 == 0) {
even_at_odd++;
} else {
even_at_even++;
}
} else {
odd++;
if (i % 2 == 0) {
odd_at_odd++;
} else {
odd_at_even++;
}
}
}
if (n == 1) {
if (even) {
printf("2\n");
continue;
} else {
printf("1\n");
continue;
}
}
if (n % 2 == 0) {
even -= even_at_odd;
odd -= odd_at_odd;
odd -= odd_at_even;
even -= max(even_at_even - 1, 0);
if (even) {
printf("2\n");
} else {
printf("1\n");
}
} else {
odd -= odd_at_even;
even -= even_at_even;
even -= even_at_odd;
odd -= max(odd_at_odd - 1, 0);
if (odd) {
printf("1\n");
} else {
printf("2\n");
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5;
const long long int MOD = 998244353;
vector<int> adj[MAX_N];
long long int pow2[MAX_N];
long long int dp1[MAX_N], dp2[MAX_N], dp3[MAX_N];
long long int inv[MAX_N];
long long int ans[MAX_N];
long long int power(long long int a, long long int n) {
if (a >= MOD) a -= MOD;
long long int ans = 1;
while (n > 0) {
if (n & 1) ans = ans * a % MOD;
a = a * a % MOD;
n /= 2;
}
return ans;
}
void func(int i) {
if (adj[i].empty()) {
dp1[i] = inv[i] = 1ll;
dp2[i] = dp3[i] = 0;
ans[i] = 1ll;
return;
}
long long int A = 1, B = 1, tmp = 1, C = 1;
for (auto p : adj[i]) {
func(p);
A = A * (dp1[p] + ans[p]) % MOD;
B = B * ans[p] % MOD;
tmp = tmp + inv[p] * dp1[p] % MOD;
if (tmp >= MOD) tmp -= MOD;
}
dp1[i] = A - B + MOD;
if (dp1[i] >= MOD) dp1[i] -= MOD;
dp2[i] = A - B * tmp % MOD;
if (dp2[i] < 0) dp2[i] += MOD;
dp3[i] = B;
ans[i] = dp2[i] + dp3[i];
if (ans[i] >= MOD) ans[i] -= MOD;
inv[i] = power(ans[i], MOD - 2);
}
int main() {
int n;
scanf("%d", &n);
pow2[0] = 1ll;
for (int i = 1; i < n; i++) {
pow2[i] = pow2[i - 1] * 2;
if (pow2[i] >= MOD) pow2[i] -= MOD;
int tmp;
scanf("%d", &tmp);
adj[tmp - 1].push_back(i);
}
pow2[0] = 2;
for (int i = 0; i < n; i++) dp1[i] = dp2[i] = dp3[i] = 0;
func(0);
printf("%lld\n", ans[0]);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
double d[100005];
double x[100005];
double y[100005];
double f(double x1, double y1, double x2, double y2, double pointX,
double pointY) {
double diffX = x2 - x1;
float diffY = y2 - y1;
if ((diffX == 0) && (diffY == 0)) {
diffX = pointX - x1;
diffY = pointY - y1;
return sqrt(diffX * diffX + diffY * diffY);
}
float t = ((pointX - x1) * diffX + (pointY - y1) * diffY) /
(diffX * diffX + diffY * diffY);
if (t < 0) {
diffX = pointX - x1;
diffY = pointY - y1;
} else if (t > 1) {
diffX = pointX - x2;
diffY = pointY - y2;
} else {
diffX = pointX - (x1 + t * diffX);
diffY = pointY - (y1 + t * diffY);
}
return sqrt(diffX * diffX + diffY * diffY);
}
int main() {
int n;
double cx, cy;
double mx = 0.0, mn = DBL_MAX;
cin >> n >> cx >> cy;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
double dx = x[i] - cx;
double dy = y[i] - cy;
double dz = dx * dx + dy * dy;
d[i] = sqrt(dz);
if (i > 0) {
double pd = f(x[i], y[i], x[i - 1], y[i - 1], cx, cy);
mn = min(mn, pd);
if (i == n - 1) mn = min(mn, f(x[0], y[0], x[n - 1], y[n - 1], cx, cy));
}
mx = max(mx, d[i]);
}
double a1 = 3.14159265358979323846 * mx * mx;
double a2 = 3.14159265358979323846 * mn * mn;
double ans = a1 - a2;
printf("%.18lf\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
unordered_map<int, int> f, g;
vector<int> p;
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
++f[a];
++g[b];
p.push_back(a);
p.push_back(b);
}
sort(p.begin(), p.end());
p.erase(unique(p.begin(), p.end()), p.end());
vector<pair<int, int>> v;
int s = 0, t = INT_MIN;
for (int x : p) {
int a = f[x], b = g[x];
if (s < k && s + a >= k) t = x;
s += a;
if (s >= k && s - b < k) v.push_back(make_pair(t, x));
s -= b;
}
cout << v.size() << endl;
for (auto& x : v) printf("%d %d\n", x.first, x.second);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 5 + 1e5;
const int INF = 1e9;
bool isPrime[N], T[N];
vector<int> primes;
vector<pair<int, int>> ans;
vector<int> te;
void sieve(int n) {
memset(isPrime, 1, sizeof isPrime);
isPrime[0] = isPrime[1] = 0;
for (int i = 2; i * i <= n; i++) {
if (isPrime[i]) {
for (int j = i * i; j <= n; j += i) isPrime[j] = 0;
}
}
for (int i = 0; i <= n; i++)
if (isPrime[i]) primes.push_back(i);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
sieve(100000);
int n;
cin >> n;
reverse(primes.begin(), primes.end());
for (auto x : primes) {
for (int i = x; i <= n; i += x) {
if (!T[i]) te.push_back(i);
}
int m = te.size();
if (m & 1) {
if (m > 2) te.erase(te.begin() + 1);
m--;
}
for (int j = 0; j < m; j += 2) {
ans.push_back({te[j], te[j + 1]});
T[te[j]] = 1;
T[te[j + 1]] = 1;
}
te.clear();
}
n = ans.size();
cout << n << "\n";
for (int i = 0; i < n; ++i)
cout << ans[i].first << " " << ans[i].second << "\n";
}
| 17 |
#include <bits/stdc++.h>
const double E = 2.7182818284590452353602874713527;
using namespace std;
vector<int> vc[10000];
int visit[100000], a, k, ara[10000], ar[10000], mp[100000];
queue<int> qu;
void bfs(int node) {
int i, u, sz, v;
qu.push(node);
while (!qu.empty()) {
u = qu.front();
qu.pop();
sz = vc[u].size();
visit[u] = 1;
for (i = 0; i < sz; i++) {
v = vc[u][i];
if (!visit[v]) {
qu.push(v);
visit[v] = 1;
}
}
}
}
int main() {
int n, l, num, i, j, nod, cnt = 0, count = 0, m;
scanf("%d%d", &n, &l);
for (i = 0; i < n; i++) {
scanf("%d", &num);
if (num == 0) {
count++;
}
for (j = 0; j < num; j++) {
scanf("%d", &ar[j]);
if (mp[ar[j]] == 0) {
ara[k] = ar[j];
mp[ar[j]] == 1;
k++;
}
for (m = 0; m < j; m++) {
vc[ar[j]].push_back(ar[m]);
vc[ar[m]].push_back(ar[j]);
}
}
}
for (i = 0; i < k; i++) {
if (!visit[ara[i]]) {
bfs(ara[i]);
cnt++;
}
}
if (cnt)
printf("%d\n", count + cnt - 1);
else
printf("%d\n", count);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l, m, p;
vector<int> le;
long long re;
int main() {
scanf("%d%d%d", &n, &k, &l);
m = n * k;
le.resize(m);
for (int i = (0); i < (m); i++) scanf("%d", &le[i]);
sort(le.begin(), le.end());
p = 0;
while (p < m && (le[p] - le[0] <= l)) p++;
if (p < n) {
printf("0");
return 0;
}
re = le[0];
int cp = 0, del = 1;
while (cp + k < p - n + del) {
cp += k;
del++;
re += le[cp];
}
for (int i = (p - 1); i >= (p - n + del); i--) re += le[i];
printf("%lld", re);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long> s;
vector<long>::iterator it;
long visited[100002];
vector<long> adj[100002];
int main() {
memset(visited, 0, sizeof(visited));
long i, j, el, k, n;
cin >> n;
for (long int i = 2; i < n + 1; i++) {
cin >> el;
adj[el].push_back(i);
}
long ans = 0;
s.push_back(1);
i = 0;
while (i < n) {
k = s.size();
ans += (k - i) % 2;
for (; i < k; i++) {
for (long int j = 0; j < adj[s[i]].size(); j++) {
s.push_back(adj[s[i]][j]);
}
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const int INF = 5e8;
int T, x[5], y[5];
int d[5], p[5], ans;
int tx[5], ty[5];
void update(int &l, int &r, int L, int R) { l = max(l, L), r = min(r, R); }
bool solve(int mid, bool flag) {
int Lx, Rx, Ly, Ry, Lc, Rc;
int La, Ra, Lb, Rb, Lac, Rac, Lbc, Rbc;
La = Lb = Lac = Lbc = -INF, Ra = Rb = Rac = Rbc = INF;
for (int i = 1; i <= 4; i++) {
if (d[i] == 1)
Lx = x[i], Rx = x[i] + mid, Ly = Ry = y[i];
else if (d[i] == 2)
Lx = Rx = x[i], Ly = y[i], Ry = y[i] + mid;
else if (d[i] == 3)
Lx = x[i] - mid, Rx = x[i], Ly = Ry = y[i];
else
Lx = Rx = x[i], Ly = y[i] - mid, Ry = y[i];
if (p[i] == 1 || p[i] == 4)
update(La, Ra, Lx, Rx);
else
update(Lac, Rac, Lx, Rx);
if (p[i] == 1 || p[i] == 2)
update(Lb, Rb, Ly, Ry);
else
update(Lbc, Rbc, Ly, Ry);
}
if (La > Ra || Lb > Rb || Lac > Rac || Lbc > Rbc) return 0;
Lc = max(Lac - Ra, Lbc - Rb), Rc = min(Rac - La, Rbc - Lb);
Lc = max(1, Lc);
if (Lc > Rc) return 0;
if (flag) {
int c = Lc, a = max(La, Lac - c), b = max(Lb, Lbc - c);
for (int i = 1; i <= 4; i++) {
if (p[i] == 1 || p[i] == 4)
tx[i] = a;
else
tx[i] = a + c;
if (p[i] == 1 || p[i] == 2)
ty[i] = b;
else
ty[i] = b + c;
}
}
return 1;
}
void dfs(int x) {
if (x > 5) {
int l, r, mid, res;
for (int i = 1; i <= 4; i++) p[i] = i;
do {
l = 0, r = ans, res = ans + 1;
while (l <= r) {
mid = (l + r) >> 1;
if (solve(mid, 0))
res = mid, r = mid - 1;
else
l = mid + 1;
}
if (res <= ans) {
ans = res, solve(res, 1);
}
} while (next_permutation(p + 1, p + 5));
return;
}
for (int i = 1; i <= 4; i++) d[x] = i, dfs(x + 1);
}
int main() {
read(T);
while (T--) {
ans = INF;
for (int i = 1; i <= 4; i++) read(x[i]), read(y[i]);
dfs(1);
if (ans == INF)
puts("-1");
else {
printf("%d\n", ans);
for (int i = 1; i <= 4; i++) printf("%d %d\n", tx[i], ty[i]);
}
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, k;
string s;
char c;
cin >> n >> k >> s;
vector<bool> let(26, 0);
for (int i = 0; i < k; i++) {
cin >> c;
let[c - 'a'] = 1;
}
long long cnt = 0, ans = 0;
for (char c : s) {
if (let[c - 'a'])
cnt++;
else {
ans += cnt * (cnt + 1) / 2;
cnt = 0;
}
}
ans += cnt * (cnt + 1) / 2;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 502;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int mat[4][4] = {{4, 3, 6, 12}, {7, 5, 9, 15}, {14, 1, 11, 10}, {13, 8, 16, 2}};
int ans[N][N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
while (cin >> n) {
if (n == 3) {
cout << "1 7 9\n3 2 5\n4 8 6" << '\n';
} else if (n <= 2) {
cout << -1 << '\n';
} else {
int id = 0;
for (int i = 0; i < 4; i++) {
if (!(i & 1)) {
for (int j = 0; j < n - 4; j++) ans[i][j] = ++id;
} else {
for (int j = n - 4 - 1; j >= 0; j--) ans[i][j] = ++id;
}
}
for (int i = 4; i < n; i++) {
if (!(i & 1)) {
for (int j = 0; j < n; j++) {
if (n > 4 && i == n - 1 && j == n - 3) continue;
ans[i][j] = ++id;
}
} else {
for (int j = n - 1; j >= 0; j--) {
if (n > 4 && i == n - 1 && j == n - 3) continue;
ans[i][j] = ++id;
}
}
}
if (n > 4) ans[n - 1][n - 3] = ++id;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
ans[i][n - 4 + j] = mat[i][j] + id;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, num;
int v[1024];
memset(v, 0, sizeof(int) * 1024);
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &num);
v[num]++;
}
int sum = 0;
while (n > 0) {
for (int i = 0; i < 1024; i++) {
if (v[i] > 0) {
n--;
v[i]--;
sum++;
}
}
sum--;
}
cout << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long p[4 * 100010], n, s, cnt1, cnt2, t1, t2, mx, mx1, mx2;
vector<pair<int, int> > p1, p2;
int main() {
cin >> n >> s;
for (int i = 1; i <= n; i++) {
cin >> p[i] >> t1 >> t2;
if (t1 >= t2) {
cnt1 += p[i];
mx = mx + p[i] * 1LL * t1;
p1.push_back(make_pair(t1 - t2, i));
} else {
cnt2 += p[i];
mx = mx + p[i] * 1LL * t2;
p2.push_back(make_pair(t2 - t1, i));
}
}
sort(p1.begin(), p1.end());
sort(p2.begin(), p2.end());
if (cnt1 % s + cnt2 % s > s) {
cout << mx << endl;
return 0;
}
mx1 = mx;
long long kol = cnt1 % s;
long long idx = 0;
for (int i = 0; i < kol; i++) {
if (p[p1[idx].second] > 0) {
p[p1[idx].second]--;
mx1 -= p1[idx].first;
} else {
idx++;
i--;
}
}
mx2 = mx;
kol = cnt2 % s;
idx = 0;
for (int i = 0; i < kol; i++) {
if (p[p2[idx].second] > 0) {
p[p2[idx].second]--;
mx2 -= p2[idx].first;
} else {
idx++;
i--;
}
}
cout << max(mx1, mx2) << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int a[100005];
int cnt[500][100005];
int num[500];
int main() {
int i, j, n, T, up, x, y, ret;
scanf("%d%d", &n, &T);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
m[a[i]]++;
}
map<int, int>::iterator it;
up = 0;
for (it = m.begin(); it != m.end(); it++) {
if (it->second >= it->first) num[up++] = it->first;
}
for (i = 0; i < up; i++) {
cnt[i][0] = 0;
for (j = 1; j <= n; j++) {
cnt[i][j] = cnt[i][j - 1] + (num[i] == a[j]);
}
}
while (T--) {
scanf("%d%d", &x, &y);
ret = 0;
for (i = 0; i < up; i++) {
if (num[i] == cnt[i][y] - cnt[i][x - 1]) ret++;
}
printf("%d\n", ret);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
string s[300005], sol, b[300005], ans[300005];
int n, m, mini;
bool p;
bitset<300005> taj;
const int inf = 1e9;
void check(string t, bool f) {
int br = 0;
bitset<300005> sad;
for (int i = 0; i < n; ++i) {
int br1 = 0, br2 = 0;
for (int j = 0; j < m; ++j) {
br1 += (s[i][j] != t[((i & 1) * 2) + (j & 1)]);
br2 += (s[i][j] != t[((i & 1) * 2) + ((j & 1) ^ 1)]);
}
if (br2 < br1) {
sad[i] = 1;
}
br += min(br1, br2);
}
if (br < mini) {
mini = br;
sol = t;
p = f;
taj = sad;
}
}
void solvepart(bool f) {
string a = "ACGT";
do {
check(a, f);
} while (next_permutation(a.begin(), a.end()));
}
void rotatematrix(string (&a)[300005]) {
for (int i = 0; i < m; ++i) {
b[i].clear();
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
b[i] += a[j][i];
}
}
swap(n, m);
for (int i = 0; i < n; ++i) {
a[i] = b[i];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
mini = inf;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
solvepart(0);
rotatematrix(s);
solvepart(1);
if (!p) {
swap(n, m);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
ans[i] += sol[((i & 1) * 2) + ((j & 1) ^ taj[i])];
}
}
if (p) {
rotatematrix(ans);
}
for (int i = 0; i < n; ++i) {
cout << ans[i] << endl;
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
#define LL long long
#define ull unsigned long long
#define F(i, j, k) for (int i = j; i <= k; ++i)
#define DF(i, j, k) for (int i = j; i >= k; --i)
using namespace std;
template <typename T> inline void read(T &n) {
T w = 1; n = 0;
char ch = getchar();
while (!isdigit(ch) && ch != EOF) { if (ch == '-') w = -1; ch = getchar(); }
while (isdigit(ch) && ch != EOF) { n = (n << 3) + (n << 1) + (ch & 15); ch = getchar(); }
n *= w;
}
template <typename T> inline void write(T x) {
T l = 0; ull y = 0;
if (!x) { putchar(48); return; }
if (x < 0) { x = -x; putchar('-'); }
while (x) { y = y * 10 + x % 10; x /= 10; ++l; }
while (l) { putchar(y % 10 + 48); y /= 10; --l; }
}
template <typename T> inline void writes(T x) {
write(x);
putchar(' ');
}
template <typename T> inline void writeln(T x) {
write(x);
puts("");
}
template <typename T> inline void checkmax(T &a, T b) { a = a > b ? a : b; }
template <typename T> inline void checkmin(T &a, T b) { a = a < b ? a : b; }
const int N = 5e6 + 100;
int n, m, seed, base, ret, y[N], b[N], w[N], t[N], a[N], p[N], k[N];
inline int rnd() {
ret = seed;
seed = ((LL)seed * base + 233) % 1000000007;
return ret;
}
inline void get() {
p[0] = 0;
F(i, 1, m) {
seed = b[i];
base = w[i];
F(j, p[i - 1] + 1, p[i]) {
t[j] = (rnd() % 2);
a[j] = (rnd() % k[i]) + 1;
}
}
}
inline void out() {
int ans = 1;
F(i, 1, n) ans = (LL)ans * ((((LL)(y[i] - a[i]) ^ ((LL)i * i)) + 1LL) % 1000000007) % 1000000007;
writeln(ans);
}
int main () {
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
read(n);
read(m);
F(i, 1, m) { read(p[i]); read(k[i]); read(b[i]); read(w[i]); }
get();
LL s0 = 0, s1 = 0;
F(i, 1, n) y[i] = a[i];
F(i, 1, n) if (!t[i]) s0 += a[i]; else s1 += a[i];
if (s0 < s1) {
F(i, 1, n) t[i] = !t[i];
swap(s0, s1);
}
if (s0 == s1) { puts("0"); return 0; }
if (s1 == 0) { a[1]--; out(); return 0; }
int st = 1;
if (!t[1]) {
--a[1];
F(i, 2, n) if (t[i]) st = i;
}
LL sum = 0;
F(i, st, n * 3) {
int no = i % n;
if (no == 0) no = n;
if (t[no]) { sum += a[no]; a[no] = 0; }
else {
if (sum >= a[no]) { sum -= a[no]; a[no] = 0; }
else { a[no] -= sum; sum = 0; }
}
}
out();
return 0;
} | 24 |
#include <bits/stdc++.h>
using namespace std;
bool flag[3607][3607];
bool vis1[3607], vis2[3607];
int f[3607][3607], g[3607][3607], c[3607][3607];
int pre[3607];
int cnt1, cnt2;
int n, m, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
c[0][0] = 1;
for (int i = 1; i <= n || i <= m; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 998244353;
}
pre[0] = 1;
for (int i = 1; i <= n || i <= m; i++)
pre[i] = (1LL * pre[i - 1] * i) % 998244353;
memset(flag, true, sizeof(flag));
while (k--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
flag[a][b] = false;
flag[c][d] = false;
}
cnt1 = 0;
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
vis1[i] = true;
for (int j = 1; j <= m; j++) vis1[i] &= flag[i][j];
if (vis1[i]) ++cnt1;
for (int j = 0; j <= n; j++) f[i][j] = f[i - 1][j];
if (vis1[i] && vis1[i - 1]) {
for (int j = 1; j <= n; j++)
f[i][j] = (f[i][j] + f[i - 2][j - 1]) % 998244353;
}
}
cnt2 = 0;
g[0][0] = 1;
for (int i = 1; i <= m; i++) {
vis2[i] = true;
for (int j = 1; j <= n; j++) vis2[i] &= flag[j][i];
if (vis2[i]) ++cnt2;
for (int j = 0; j <= m; j++) g[i][j] = g[i - 1][j];
if (vis2[i] && vis2[i - 1]) {
for (int j = 1; j <= m; j++)
g[i][j] = (g[i][j] + g[i - 2][j - 1]) % 998244353;
}
}
int ans = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++)
if (2 * i + j <= cnt1 && i + 2 * j <= cnt2) {
int tmp = (1LL * c[cnt1 - 2 * i][j] * c[cnt2 - 2 * j][i]) % 998244353;
tmp = (1LL * tmp * f[n][i]) % 998244353;
tmp = (1LL * tmp * g[m][j]) % 998244353;
tmp = (1LL * tmp * pre[i]) % 998244353;
tmp = (1LL * tmp * pre[j]) % 998244353;
ans = (ans + tmp) % 998244353;
}
printf("%d\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
while (cin >> n >> l) {
int res = 0xffff;
int m;
for (int i = 0; i < n; i++) {
cin >> m;
if (l % m == 0 && l / m < res) res = l / m;
}
cout << res << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <typename A,
typename B = typename enable_if<!is_same<A, string>::value,
typename A::value_type>::type>
ostream &operator<<(ostream &out, A v) {
out << '{';
string sep;
for (const B &x : v) out << sep << x, sep = ", ";
return out << '}';
}
void dbgPrint() { cerr << endl; }
template <typename A, typename... B>
void dbgPrint(A a, B... b) {
cerr << ' ' << a;
dbgPrint(b...);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
array<vector<ll>, 2> dp;
for (int i = 0; i < 2; i++) {
dp[i] = vector<ll>(41, 0);
}
dp[0][1] = 4;
dp[1][1] = 2;
for (int i = 2; i < 41; i++) {
dp[0][i] = dp[0][i - 1] * 4;
dp[1][i] = dp[1][i - 1] * 2;
dp[0][i - 1] = (dp[0][i - 1] - 1) / 3;
dp[1][i - 1] += dp[1][i - 2] - 1;
}
int t;
cin >> t;
while (t--) {
ll n, k;
cin >> n >> k;
if (n > 31) {
cout << "YES " << n - 1 << '\n';
} else if (k > dp[0][n] || (n == 2 && k == 3)) {
cout << "NO\n";
} else {
for (int i = 1; i <= n; i++) {
if (k >= dp[1][i] && k <= dp[0][i] + dp[0][n - i] * ((1ll << i) - 1) *
((1ll << i) - 1)) {
cout << "YES " << n - i << '\n';
break;
}
}
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t, z = -1, x = 0, y = 0;
cin >> n >> k >> t;
if (t <= k)
cout << t;
else if (t - k <= n - k)
cout << k;
else if (t - k > n - k)
cout << n + k - t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int cnt = 0;
vector<int> V1;
V1.push_back(2);
V1.push_back(3);
V1.push_back(5);
V1.push_back(7);
V1.push_back(11);
V1.push_back(13);
V1.push_back(17);
V1.push_back(19);
V1.push_back(23);
V1.push_back(29);
V1.push_back(31);
V1.push_back(37);
V1.push_back(41);
V1.push_back(43);
V1.push_back(47);
int i, c = 1;
bool flag = false;
for (i = 0; i < V1.size() && V1[i] <= 100 / c; i++) {
cout << V1[i] << endl;
cout.flush();
cin >> s;
if (s.compare("yes") == 0) {
cnt++;
c = V1[i];
if (cnt == 1) {
cout << V1[i] * V1[i] << endl;
cout.flush();
cin >> s;
if (s.compare("yes") == 0) {
cnt++;
}
}
}
if (cnt == 2) {
cout << "composite" << endl;
cout.flush();
flag = true;
break;
}
if (V1[i] == 7 && cnt == 0) {
cout << "prime" << endl;
cout.flush();
flag = true;
break;
}
}
if (!flag) {
cout << "prime" << endl;
cout.flush();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <class T>
void cxk(T& a, T b) {
a = a > b ? a : b;
}
template <class T>
void cnk(T& a, T b) {
a = a < b ? a : b;
}
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
bool debug = 0;
int n, m, A[10000], B[10000], E[51][51], rE[51][51];
std::vector<int> w[10000], rw[10000], G[51], rG[51];
void inc(int& x, int y) {
x = x + y >= 1000000007 ? x + y - 1000000007 : x + y;
}
void dec(int& x, int y) { x = x >= y ? x - y : x + 1000000007 - y; }
int sub(int x, int y) { return x >= y ? x - y : x + 1000000007 - y; }
std::vector<int> path[51][51][2][2];
int f[110][51][2], ans[110];
std::vector<int> seq, rseq;
bool extend(int p, std::vector<int>& seq, int E[51][51],
std::vector<int> w[10000]) {
if (p == seq.size() - 1) return seq.size() <= n + n;
int y = seq[p + 1], x = seq[p];
if (E[x][y]) {
for (int i : w[E[x][y]]) seq.push_back(i);
return seq.size() <= n + n && extend(p + 1, seq, E, w);
} else
return 0;
}
int main() {
n = gi(), m = gi();
for (int i = 1; i <= m; ++i) {
int u = gi(), v = gi();
A[i] = u, B[i] = v;
G[u].push_back(v), G[v].push_back(u);
E[u][v] = rE[v][u] = i;
w[i].resize(gi());
for (int j = 0; j < w[i].size(); ++j) w[i][j] = gi();
rw[i] = w[i], std::reverse((rw[i]).begin(), (rw[i]).end());
}
for (int i = 1; i <= m; ++i)
if (w[i].size() && w[i].back() == A[i]) {
seq = rw[i];
if (extend(0, seq, rE, rw)) {
path[seq.back()][B[i]][0][0].push_back(seq.size());
if (debug) {
printf("-1 -1 path :");
for (int i : seq) printf("%d ", i);
puts("");
}
}
}
for (int i = 1; i <= m; ++i)
if (w[i].size() && w[i][0] == B[i]) {
seq = w[i];
if (extend(0, seq, E, w)) {
path[A[i]][seq.back()][1][1].push_back(seq.size());
if (debug) {
printf("0 0 path :");
for (int i : seq) printf("%d ", i);
puts("");
}
}
}
bool found = 1;
for (int i = 1; i <= m; ++i)
if (w[i].size()) {
int p = -1;
for (int j = 1; j < w[i].size(); ++j)
if (w[i][j - 1] == A[i] && w[i][j] == B[i]) p = j;
if (p == -1) continue;
seq = rseq = {};
for (int j = p - 1; ~j; --j) rseq.push_back(w[i][j]);
for (int j = p; j < w[i].size(); ++j) seq.push_back(w[i][j]);
if (extend(0, seq, E, w) && extend(0, rseq, rE, rw)) {
path[rseq.back()][seq.back()][0][1].push_back(seq.size() + rseq.size() -
1);
std::reverse((rseq).begin(), (rseq).end());
if (!found) {
printf("%d\n", seq.size() + rseq.size());
for (int i : rseq) printf("%d ", i);
for (int i : seq) printf("%d ", i);
puts("");
found = 1;
}
if (debug) {
printf("-1 0 path :");
for (int i : rseq) printf("%d ", i);
for (int i : seq) printf("%d ", i);
puts("");
}
}
}
if (!found) puts("0\n");
for (int i = 1; i <= m; ++i)
if (w[i].empty()) {
path[A[i]][B[i]][1][0].push_back(1);
if (debug) printf("0 -1 path :%d %d\n", A[i], B[i]);
}
for (int i = 1; i <= n; ++i) f[0][i][0] = 1;
for (int le = 0; le <= n + n; ++le)
for (int i = 1; i <= n; ++i)
for (int o = 0; o < 2; ++o) {
if (!f[le][i][o]) continue;
if (debug) printf("%d %d %d %d\n", le, i, o, f[le][i][o]);
if (o) inc(ans[le], f[le][i][o]);
for (int j = 1; j <= n; ++j)
for (int to = 0; to < 2; ++to)
for (int nl : path[i][j][o][to])
if (nl + le <= n + n) inc(f[le + nl][j][to], f[le][i][o]);
}
for (int i = 1; i <= n + n; ++i) printf("%d\n", ans[i]);
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
int a[n + 1];
int x = 1;
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
a[p] = x;
prime[p] = false;
for (int i = p * p; i <= n; i += p) {
prime[i] = false;
a[i] = x;
}
++x;
}
}
for (int p = 2; p <= n; p++) {
if (prime[p])
cout << x++ << " ";
else
cout << a[p] << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
int n;
cin >> n;
SieveOfEratosthenes(n);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
struct ppap {
long long v, i, op;
} a[100010];
long long ansx[100010], ansy[100010], n, m;
inline bool cmp(ppap a, ppap b) { return a.v == b.v ? a.op > b.op : a.v < b.v; }
signed main() {
n = read();
m = read();
for (long long i = 1; i <= m; i++) {
a[i].i = i;
a[i].v = read();
a[i].op = read();
}
sort(a + 1, a + m + 1, cmp);
long long cnt = 1, rpx = 1, rpy = 3;
for (long long i = 1; i <= m; i++) {
if (!a[i].op) {
if (rpy > cnt)
return puts("-1") & 0;
else {
ansx[a[i].i] = rpx, ansy[a[i].i] = rpy;
rpx++;
if (rpx == rpy - 1) rpy++, rpx = 1;
}
} else
ansx[a[i].i] = cnt, ansy[a[i].i] = ++cnt;
}
for (long long i = 1; i <= m; i++) {
write(ansx[i]);
putchar(' ');
writeln(ansy[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
int X;
int A[maxn];
struct node {
vector<pair<int, int> > L, R;
long long ans;
} T[maxn << 2];
node merge(const node &A, const node &B) {
node ret;
long long orL = 0, orR = 0;
for (auto now : A.L) orL |= now.first, ret.L.push_back(now);
for (auto now : B.R) orR |= now.first, ret.R.push_back(now);
for (auto now : B.L) {
int nxt = now.first | orL;
if (ret.L[ret.L.size() - 1].first == nxt)
ret.L[ret.L.size() - 1].second += now.second;
else
ret.L.push_back(make_pair(nxt, now.second));
}
for (auto now : A.R) {
int nxt = now.first | orR;
if (ret.R[ret.R.size() - 1].first == nxt)
ret.R[ret.R.size() - 1].second += now.second;
else
ret.R.push_back(make_pair(nxt, now.second));
}
ret.ans = A.ans + B.ans;
long long cnt = 0;
int i = B.L.size() - 1;
for (auto now : A.R) {
while (i >= 0 && (B.L[i].first | now.first) >= X) cnt += B.L[i].second, i--;
ret.ans += (long long)now.second * cnt;
}
return ret;
}
void build(int x, int L, int R) {
if (L == R) {
T[x].L.push_back(make_pair(A[L], 1));
T[x].R.push_back(make_pair(A[R], 1));
T[x].ans = (A[L] >= X);
return;
}
int mid = (L + R) / 2;
build(x << 1, L, mid);
build(x << 1 | 1, mid + 1, R);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
void update(int x, int pos, int L, int R) {
if (L == R) {
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(A[L], 1));
T[x].R.push_back(make_pair(A[R], 1));
T[x].ans = (A[L] >= X);
return;
}
int mid = (L + R) / 2;
if (pos <= mid) update(x << 1, pos, L, mid);
if (mid < pos) update(x << 1 | 1, pos, mid + 1, R);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
node query(int x, int l, int r, int L, int R) {
if (l <= L && R <= r) return T[x];
int mid = (L + R) / 2;
if (r <= mid) return query(x << 1, l, r, L, mid);
if (mid < l) return query(x << 1 | 1, l, r, mid + 1, R);
return merge(query(x << 1, l, r, L, mid),
query(x << 1 | 1, l, r, mid + 1, R));
}
int TaskA() {
int n, m, i;
scanf("%d%d%d", &n, &m, &X);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
build(1, 1, n);
for (i = 1; i <= m; i++) {
int op, l, r;
scanf("%d%d%d", &op, &l, &r);
if (op == 1) {
A[l] = r;
update(1, l, 1, n);
} else {
printf("%I64d\n", query(1, l, r, 1, n).ans);
}
}
return 0;
}
void initialize() {}
int main() {
int startTime = clock();
initialize();
fprintf(stderr, "/--- initializeTime: %ld milliseconds ---/\n",
clock() - startTime);
int T = 1;
startTime = clock();
while (T--) TaskA();
fprintf(stderr, "/--- computeTime: %ld milliseconds ---/\n",
clock() - startTime);
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
vector<pair<long long, long long> > graph[100010];
struct subset {
int parent;
int rank;
};
struct Node {
int u, v;
long long w;
Node() {}
Node(int _u, int _v, long long _w) {
u = _u;
v = _v;
w = _w;
}
bool operator<(const Node &tmp) const { return w > tmp.w; }
};
priority_queue<Node> pq;
vector<int> special;
vector<long long> dist[maxn];
subset subsets[maxn];
vector<pair<long long, long long> > g[maxn];
int n, test;
long long d[maxn];
int dep[maxn];
int f[maxn][22];
void dfs(int u, int fa, long long w) {
f[u][0] = fa;
d[u] = w;
dep[u] = dep[fa] + 1;
for (int i = 1; i <= 20; i++) {
f[u][i] = f[f[u][i - 1]][i - 1];
}
for (auto v : g[u]) {
if (v.first == fa) continue;
dfs(v.first, u, w + v.second);
}
}
int get_lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int delta = dep[a] - dep[b];
for (int i = 20; i >= 0; i--) {
if (delta >> i & 1) {
a = f[a][i];
}
}
if (a == b) return a;
for (int i = 20; i >= 0; i--) {
if (f[a][i] != f[b][i]) {
a = f[a][i];
b = f[b][i];
}
}
return f[a][0];
}
void SET() {
for (int i = 0; i < maxn; i++) {
subsets[i].parent = i;
subsets[i].rank = 0;
}
}
int find(struct subset subsets[], int i) {
if (subsets[i].parent != i)
subsets[i].parent = find(subsets, subsets[i].parent);
return subsets[i].parent;
}
void Union(struct subset subsets[], int x, int y) {
int xroot = find(subsets, x);
int yroot = find(subsets, y);
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank > subsets[yroot].rank)
subsets[yroot].parent = xroot;
else {
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
vector<long long> Dijkstra(int N, long long s) {
vector<long long> dis(N + 1, 1e18 + 7);
dis[s] = 0;
priority_queue<Node> pq;
pq.push(Node(s, 0, 0));
while (pq.size()) {
long long u = pq.top().u;
long long dd = pq.top().w;
pq.pop();
for (auto pr : graph[u]) {
long long nw = dd + pr.second;
long long v = pr.first;
if (dis[v] <= nw) continue;
dis[v] = nw;
pq.push(Node(v, 0, dis[v]));
}
}
return dis;
}
int main() {
int n, m;
SET();
cin >> n >> m;
for (int i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
graph[u].push_back(make_pair(v, w));
graph[v].push_back(make_pair(u, w));
pq.push(Node(u, v, w));
}
while (!pq.empty()) {
int u, v;
u = pq.top().u;
v = pq.top().v;
long long w = pq.top().w;
pq.pop();
int f1 = find(subsets, u);
int f2 = find(subsets, v);
if (f1 != f2) {
g[u].push_back(make_pair(v, w));
g[v].push_back(make_pair(u, w));
Union(subsets, f1, f2);
} else {
special.push_back(u);
special.push_back(v);
}
}
dfs(1, 0, 0);
for (auto x : special) {
dist[x] = Dijkstra(n, x);
}
int q;
cin >> q;
while (q--) {
int u, v;
cin >> u >> v;
long long lc = get_lca(u, v);
long long mn = d[u] + d[v] - 2 * d[lc];
for (auto x : special) {
mn = min(mn, dist[x][u] + dist[x][v]);
}
cout << mn << endl;
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 5;
bool vis[MAXN];
int main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int fdv = a[n - 1];
vis[fdv] = 1;
a[n - 1] = 0;
for (int i = 0; i < n; i++) {
if (a[i] and !vis[a[i]] and (fdv % a[i]) == 0) {
vis[a[i]] = 1;
a[i] = 0;
}
}
sort(a, a + n);
cout << fdv << ' ' << a[n - 1];
}
| 3 |
#include <bits/stdc++.h>
using std::max;
using std::swap;
using std::vector;
const int MAXN = 1e5 + 10;
int n, a, b, da, db;
vector<int> e[MAXN];
int d[MAXN], f[MAXN], g[MAXN], len;
void dfs(int u, int fa) {
register int v;
f[u] = g[u] = 0;
for (register int i = 0; i < (int)e[u].size(); ++i) {
v = e[u][i];
if (v != fa) {
d[v] = d[u] + 1;
dfs(v, u);
f[u] = max(f[u], g[v] + 1);
if (f[u] > g[u]) swap(f[u], g[u]);
}
}
len = max(len, f[u] + g[u]);
}
void solve() {
scanf("%d %d %d %d %d\n", &n, &a, &b, &da, &db);
register int u, v;
for (register int i = 1; i <= n; ++i) e[i].clear();
for (register int i = 2; i <= n; ++i) {
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
d[a] = 0;
len = 0;
dfs(a, 0);
if (da >= d[b] || da * 2 >= len || db <= da * 2)
printf("Alice\n");
else
printf("Bob\n");
}
int main() {
register int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, w, t, te, z[400010], coun, l, r;
vector<int> b, e, s;
int main() {
cin >> n >> w;
if (w == 1) {
cout << n;
return 0;
}
if (w > n) {
cout << 0;
return 0;
}
cin >> t;
for (int i = 1; i < n; i++) {
cin >> te;
b.push_back(te - t);
t = te;
}
cin >> t;
for (int i = 1; i < w; i++) {
cin >> te;
e.push_back(te - t);
t = te;
}
s = e;
s.push_back(INT_MAX);
for (int i = 0; i < b.size(); i++) {
s.push_back(b[i]);
}
z[0] = s.size();
for (int i = 1; i < s.size(); i++) {
if (i > r) {
l = i;
r = i;
while (r < s.size() && s[r] == s[r - l]) r++;
z[i] = r - l;
r--;
} else if (z[i - l] < r - i + 1) {
z[i] = z[i - l];
} else {
l = i;
while (r < s.size() && s[r] == s[r - l]) r++;
z[i] = r - l;
r--;
}
if (z[i] == e.size()) {
coun++;
}
}
cout << coun;
}
| 10 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int NMAX = 1000000;
vector<int> pos[300];
char buf[NMAX];
int n, k;
int main() {
scanf("%d%d", &n, &k);
gets(buf);
string s = gets(buf);
for (int i = 0; i < int(int((s).size())); ++i) pos[s[i]].push_back(i);
for (int step = 0; step < int(n); ++step) {
string c = gets(buf);
long long ans = 0;
for (int i = 0; i < int(int((c).size())); ++i) {
int idx = lower_bound((pos[c[i]]).begin(), (pos[c[i]]).end(), i) -
pos[c[i]].begin();
int minV = INF;
for (int j = idx - 5; j <= idx + 5; j++) {
if (0 <= j && j < int((pos[c[i]]).size()))
minV = min(minV, abs(pos[c[i]][j] - i));
}
if (minV == INF) minV = int((c).size());
ans += minV;
}
printf("%I64d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
int d[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int main() {
int a, b, res = 0;
scanf("%d %d", &a, &b);
while (a <= b) {
int x = a;
while (x) res += d[x % 10], x /= 10;
a++;
}
printf("%d\n", res);
}
| 2 |
Subsets and Splits