solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dsu[200005];
int fi_root(int nod) {
if (dsu[nod] == 0) {
return nod;
}
return dsu[nod] = fi_root(dsu[nod]);
}
bool unite(int x, int y) {
x = fi_root(x);
y = fi_root(y);
if (x == y) {
return false;
}
dsu[x] = y;
return true;
}
int main() {
scanf("%d %d", &n, &m);
vector<int> a(n + 1, 0);
vector<int> b(m + 1, 0);
vector<int> ord_a(n + 1, 0);
vector<int> ord_b(m + 1, 0);
vector<int> inv_a(n + 1, 0);
vector<int> inv_b(m + 1, 0);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ord_a[i] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
ord_b[i] = i;
}
sort(ord_a.begin(), ord_a.end(), [&](int i, int j) { return a[i] < a[j]; });
sort(ord_b.begin(), ord_b.end(), [&](int i, int j) { return b[i] < b[j]; });
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i <= n; i++) {
inv_a[ord_a[i]] = i;
}
for (int i = 0; i <= m; i++) {
inv_b[ord_b[i]] = i;
}
vector<vector<int> > sets = vector<vector<int> >(n + 1, vector<int>());
for (int i = 1; i <= n; i++) {
int len;
scanf("%d", &len);
vector<int> stuff;
for (int j = 1; j <= len; j++) {
int val;
scanf("%d", &val);
stuff.push_back(inv_b[val]);
}
sets[inv_a[i]] = stuff;
}
long long ans = 0;
vector<pair<int, pair<int, int> > > edges;
for (int i = 1; i <= n; i++) {
for (auto it : sets[i]) {
edges.push_back({a[i] + b[it], {i, it + n}});
}
}
sort(edges.begin(), edges.end());
reverse(edges.begin(), edges.end());
for (auto it : edges) {
if (unite(it.second.first, it.second.second) == false) {
ans += it.first;
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a, b;
void solve() {
cin >> a >> b;
if (a == b)
cout << 0 << endl;
else if (a < b) {
if ((b - a) % 2 == 0)
cout << 2 << endl;
else
cout << 1 << endl;
} else {
if ((a - b) % 2 == 0)
cout << 1 << endl;
else
cout << 2 << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int t;
cin >> t;
while (t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, x, y;
cin >> n;
int a[n], b[n + 1];
bool f[n + 1];
memset(f, false, sizeof(f));
memset(b, -1, sizeof(b));
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n;) {
j = i + 1;
while (j < n && a[j] == a[i]) j++;
b[j] = a[i], f[a[i]] = true;
i = j;
}
j = 0;
for (i = 0; i < n; i++) {
if (b[i] != -1) continue;
while (f[j]) j++;
b[i] = j, j++;
}
for (i = 0; i < n; i++) printf("%d ", b[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Query {
int num, a, b;
Query(int num = 0, int a = 0, int b = 0) : num(num), a(a), b(b) {}
bool operator<(const Query& q) const& { return b < q.b; }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
const int k = 451;
int q;
cin >> q;
vector<Query> query;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
query.emplace_back(i, a - 1, b);
}
int prev_b = -1;
sort(query.begin(), query.end());
vector<long long> sum(n);
vector<long long> ans(q);
for (int i = 0; i < q; i++) {
if (query[i].b > k) {
long long sum = 0;
for (int j = query[i].a; j < n; j += query[i].b) {
sum += a[j];
}
ans[query[i].num] = sum;
} else {
if (prev_b == query[i].b) {
ans[query[i].num] = sum[query[i].a];
} else {
prev_b = query[i].b;
for (int j = n - 1; j > -1; j--) {
sum[j] = a[j] + (j + query[i].b < n ? sum[j + query[i].b] : 0);
}
ans[query[i].num] = sum[query[i].a];
}
}
}
for (auto u : ans) {
cout << u << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 29);
const int INFF = 0x7fffffff;
const long long LINF = (1ll << 60);
const long long LINFF = 0x7fffffffffffffff;
const long double PI = 3.14159265359;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long a, long long b) {
return uniform_int_distribution<long long>(a, b)(rng);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string a, b;
cin >> a >> b;
bool ans = true;
bool change[300][300] = {};
for (int i = 0; i < n; i++) {
if (a[i] != b[i] && a[i] > b[i]) ans = false;
if (a[i] != b[i]) change[a[i]][b[i]] = true;
}
int cnt = 0;
for (int c = 'a'; c <= 't'; c++) {
for (int d = c + 1; d <= 't'; d++) {
if (change[c][d] == 0) continue;
cnt += change[c][d];
for (int e = d + 1; e <= 't'; e++) {
change[d][e] += change[c][e];
}
break;
}
}
if (ans == false) cnt = -1;
cout << cnt << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long INF = 1000LL * 1000 * 1000 * 1000 * 1000 * 1000;
const int inf = 1000 * 1000 * 1000;
const long double PI = acos(-1.0);
const long long mod1 = inf + 7;
const long long mod2 = inf + 9;
const long long bigmod = mod1;
const int MAXN = 1000005;
const long double EPS = 1e-11;
long long hp = inf / 1000 + 3;
const int N = 3e5 + 228;
signed main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
;
int n;
cin >> n;
vector<pair<int, int>> a(n);
vector<int> cnt(228);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
;
for (int j = a[i].first; j < a[i].second; ++j) {
cnt[j]++;
}
}
int ans = 0;
for (int i = a[0].first; i < a[0].second; ++i) {
if (cnt[i] == 1) {
ans++;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, m;
std::cin >> n >> m;
std::string a, b;
std::cin >> a >> b;
std::vector<std::vector<int>> DP(n + 1, std::vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] == b[j])
DP[i + 1][j + 1] = std::max(DP[i + 1][j + 1], DP[i][j] + 2);
DP[i + 1][j + 1] =
std::max(DP[i + 1][j + 1], std::max(DP[i + 1][j], DP[i][j + 1]) - 1);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans = std::max(ans, DP[i + 1][j + 1]);
}
}
std::cout << ans << std::endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int n, m, vis[1600][1600];
char s[1600][1600];
int hea[7100], nex[7100], vv[7100], uu[7100];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
void bfs(int x, int y, int k) {
while (!q.empty()) q.pop();
int cx, cy, nx, ny;
vis[x][y] = k;
q.push(x);
q.push(y);
while (!q.empty()) {
cx = q.front();
q.pop();
cy = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
nx = cx + dx[i];
ny = cy + dy[i];
if (nx < 1 || nx > n || ny < 1 || ny > m) continue;
if (vis[nx][ny] || s[nx][ny] == '#') continue;
vis[nx][ny] = k;
q.push(nx);
q.push(ny);
}
}
}
inline void adj(int u, int v, int k, int idx) {
vv[idx] = v;
uu[idx] = k;
nex[idx] = hea[u];
hea[u] = idx;
}
void init() {
memset(hea, -1, sizeof(hea));
int cnt = 0;
for (int i = 1; i <= m; ++i)
if (vis[1][i] && vis[n][i]) {
adj(vis[1][i], vis[n][i], 0, ++cnt);
adj(vis[n][i], vis[1][i], 2, ++cnt);
}
for (int i = 1; i <= n; ++i)
if (vis[i][1] && vis[i][m]) {
adj(vis[i][1], vis[i][m], 3, ++cnt);
adj(vis[i][m], vis[i][1], 1, ++cnt);
}
}
int meet[3][3][7100];
bool ok(int x, int y, int k) {
while (!q.empty()) q.pop();
memset(meet, 0, sizeof(meet));
meet[1][1][vis[x][y]] = 1;
q.push(1);
q.push(1);
q.push(vis[x][y]);
int cx, cy, cz, nx, ny, nz;
while (!q.empty()) {
cx = q.front();
q.pop();
cy = q.front();
q.pop();
cz = q.front();
q.pop();
for (int e = hea[cz]; e != -1; e = nex[e]) {
nz = vv[e];
nx = (cx + dx[uu[e]] + 3) % 3;
ny = (cy + dy[uu[e]] + 3) % 3;
if (meet[nx][ny][nz]) continue;
meet[nx][ny][nz] = 1;
q.push(nx);
q.push(ny);
q.push(nz);
}
}
for (int h = 1; h <= k; ++h) {
int cnt = 0;
for (int i = 0; i <= 2; ++i) {
for (int j = 0; j <= 2; ++j)
if (meet[i][j][h]) cnt++;
}
if (cnt > 1) return true;
}
return false;
}
int main() {
memset(vis, 0, sizeof(vis));
memset(s, 0, sizeof(s));
scanf("%d %d", &n, &m);
int x = 0, y = 0, k = 0, found = 0;
for (int i = 1; i <= n; ++i) {
scanf("%s", &s[i][1]);
if (found) continue;
for (int j = 1; j <= m; ++j)
if (s[i][j] == 'S') {
x = i;
y = j;
found = 1;
break;
}
}
for (int i = 1; i <= m; ++i) {
if (s[1][i] != '#' && !vis[1][i]) bfs(1, i, ++k);
if (s[n][i] != '#' && !vis[n][i]) bfs(n, i, ++k);
}
for (int i = 1; i <= n; ++i) {
if (s[i][1] != '#' && !vis[i][1]) bfs(i, 1, ++k);
if (s[i][m] != '#' && !vis[i][m]) bfs(i, m, ++k);
}
init();
if (ok(x, y, k))
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
vector<int> adj[MAXN];
int mark[MAXN];
pair<int, int> hd[MAXN];
int main() {
int n, m, h, t;
scanf("%d%d%d%d", &n, &m, &h, &t);
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int u = 1; u <= n; ++u) {
if (adj[u].size() < h + 1) continue;
for (int i = 0; i < adj[u].size(); ++i) mark[adj[u][i]] = u;
for (int X = 0; X < adj[u].size(); ++X) {
int v = adj[u][X];
if (adj[v].size() < t + 1) continue;
vector<int> heads, tails, both;
pair<int, int> CE = make_pair(u, v);
for (int i = 0; i < adj[v].size() && i < h + t && tails.size() < t; ++i)
if (adj[v][i] != u and mark[adj[v][i]] != u)
tails.push_back(adj[v][i]);
else if (adj[v][i] != u) {
both.push_back(adj[v][i]);
hd[adj[v][i]] = CE;
}
for (int i = 0; i < adj[u].size() && i < h + t && heads.size() < h; ++i)
if (adj[u][i] != v && hd[adj[u][i]] != CE) heads.push_back(adj[u][i]);
if (heads.size() + both.size() >= h and
tails.size() + both.size() >= t and
heads.size() + tails.size() + both.size() >= h + t) {
cout << "YES" << endl;
cout << u << " " << v << endl;
while (h--)
if (heads.size() != 0) {
cout << heads[heads.size() - 1] << " ";
heads.pop_back();
} else {
cout << both[both.size() - 1] << " ";
both.pop_back();
}
cout << endl;
while (t--)
if (tails.size() != 0) {
cout << tails[tails.size() - 1] << " ";
tails.pop_back();
} else {
cout << both[both.size() - 1] << " ";
both.pop_back();
}
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
/**
******************* Author:Bisnu sarkar ****************************
**/
/*
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
*/
//PBDS
/*
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
*/
using namespace std;
//PBDS_SET
//Index of Value - .order_of_key()
//Value at Index - .find_by_order()
/*
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> pbds_set;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update> pbds_multiset;
*/
#define fRead(x) freopen(x,"r",stdin)
#define fWrite(x) freopen (x,"w",stdout)
#define ull unsigned long long
#define ll long long
#define pii pair<int,int>
#define sit set<int> :: iterator
#define vrit vector<int> :: reverse iterator
#define ff first
#define ss second
#define endl '\n';
#define sz(s) (int)s.size()
#define all(s) s.begin(),s.end()
#define IO ios_base::sync_with_stdio(false),cin.tie(NULL);
#define what_is(x) cerr << #x << " is " << x << endl;
///*....Debugger....*///
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {cout << endl;}
template<typename T, typename... Args> void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << ", ";
err(++it, args...);
}
///*....Input....*///
template <typename T> inline void Int(T &n) {
n = 0; int f = 1; register int ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
template <typename T, typename TT> inline void Int(T &n, TT &m) { Int(n); Int(m); }
template <typename T, typename TT, typename TTT> inline void Int(T &n, TT &m, TTT &l) { Int(n, m); Int(l);}
double ind(){double x; scanf("%lf",&x);return x;}
///*....Bitmask....*///
int set_1(int n,int pos){return n = (n | (1<<pos));}
int reset_0(int n,int pos){return n= n & ~(1<<pos);}
bool check_bit(int n,int pos){return n = n & (1<<pos);}
int dx[8]= {1,0,-1,0,-1,-1,1,1};
int dy[8]= {0,1,0,-1,-1,1,-1,1};
///*....Constraints....*///
const int N = (int) 1e6 + 5;
const int M = (int) 1e9 + 7;
const double pi=2* acos(0.0);
const double eps=1e-9;
int main()
{
int t=1,te=0;
Int(t);
while(t--){
int n;
Int(n);
std::vector<int> a(n),b(n);
for (int i = 0; i < n; ++i)
{
Int(a[i]);
Int(b[i]);
}
std::vector<int> c(n);
for (int i = 0; i < n; ++i)
{
/* code */Int(c[i]);
}
ll cur = 0,cur2=0;
for(int i=0;i<n;++i){
int r=0;
if(i != 0){
r=b[i-1];
}
cur = cur2 + a[i] - r + c[i];
cur2=max(cur + (b[i]-a[i]+1)/2,(ll)b[i]);
}
printf("%lld\n", cur);
//printf("Case %d: ",++te);
}
//cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms" << '\n';
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
using namespace std;
const int MAX = 14348907; // 3 ^ 15
int N,M,init;
bool memo[MAX];
vector<int> v[3];
struct state{
int n,bit;
state(int n=0, int bit=init):n(n),bit(bit){}
};
int calcBit(int n, int pos){
return (int)pow(3,(double)pos) * n;
}
int calcN(int bit, int pos){
return (bit / (int)pow(3,(double)pos)) % 3;
}
void add(int &bit, int pos, int n){
bit -= calcBit(calcN(bit,pos), pos);
bit += calcBit(n, pos);
}
void bfs(){
queue<state> Q;
state u,v;
int max[3];
fill(memo,memo+MAX,false);
memo[init] = true;
for(Q.push(u); !Q.empty();){
u = Q.front();
Q.pop();
max[0] = max[1] = max[2] = -1;
for(int i=N-1;i>=0;i--){
if(max[calcN(u.bit,i)] == -1) max[calcN(u.bit,i)] = i;
}
if(max[1] == -1 && (max[0] == -1 || max[2] == -1)){
//for(int i=0;i<N;i++) cout << calcN(u.bit,i) << ' ';
cout << u.n << endl;
return;
}
if(u.n >= M) break;
if(max[0] > max[1]){
v = u;
add(v.bit, max[0], 1);
v.n++;
if(!memo[v.bit] ){
memo[v.bit] = true;
Q.push(v);
}
}
if(max[1] > max[0]){
v = u;
add(v.bit, max[1], 0);
v.n++;
if(!memo[v.bit]){
memo[v.bit] = true;
Q.push(v);
}
}
if(max[2] > max[1]){
v = u;
add(v.bit, max[2], 1);
v.n++;
if(!memo[v.bit]){
memo[v.bit] = true;
Q.push(v);
}
}
if(max[1] > max[2]){
v = u;
add(v.bit, max[1], 2);
v.n++;
if(!memo[v.bit]){
memo[v.bit] = true;
Q.push(v);
}
}
}
cout << -1 << endl;
}
int main(){
while(cin >> N >> M && (N|M)){
init = 0;
for(int i=0;i<3;i++){
int x;
cin >> x;
for(int j=0;j<x;j++){
int c;
cin >> c;
c--;
v[i].push_back(c);
add(init, c, i);
}
}
bfs();
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long tb[1000005], inv[1000005], invtb[1000005];
void getA() {
tb[0] = tb[1] = inv[0] = inv[1] = invtb[0] = invtb[1] = 1;
for (long long i = 2; i <= 1000005 - 1; i++) {
tb[i] = tb[i - 1] * i % 998244353;
inv[i] = (998244353 - 998244353 / i) * inv[998244353 % i] % 998244353;
invtb[i] = invtb[i - 1] * inv[i] % 998244353;
}
}
long long C(long long d, long long u) {
return tb[d] * invtb[d - u] % 998244353 * invtb[u] % 998244353;
}
long long qpow(long long a, long long b) {
long long res = 1;
a %= 998244353;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % 998244353;
a = a * a % 998244353;
}
return res;
}
long long bpow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % 998244353)
if (b & 1) res = res * a % 998244353;
return res;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int t = 1;
getA();
while (t--) {
long long n;
cin >> n;
long long a1 = 0, a2 = 0;
for (long long i = 1; i <= n; i++) {
long long x = qpow(3, n - i);
long long tmp = (998244353 + qpow(x - 1, n) - qpow(x, n)) % 998244353;
(a1 += C(n, i) * tmp % 998244353 * (i % 2 ? 1 : -1) + 998244353) %=
998244353;
}
a1 = a1 * 3 % 998244353;
for (long long i = 1; i <= n; i++) {
long long tmp = qpow(3, i + n * (n - i));
(a2 += C(n, i) * tmp % 998244353 * (i % 2 ? 1 : -1) + 998244353) %=
998244353;
}
a2 = a2 * 2 % 998244353;
cout << (a1 + a2 + 998244353) % 998244353 << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int M = 303;
double dp[M][M][M];
double f(int i, int j, int k){
if(i+j+k==0){
return 1.0;
}
if(i < 0 || i > n || j < 0 || j > n || k < 0 || k > n ){
return 0;
}
if(dp[i][j][k] > 0.00001) return dp[i][j][k];
double total = i+j+k;
return dp[i][j][k] = i/total * f(i-1,j,k) + (j/total) * f(i+1,j-1,k) + (k / total) * f(i,j+1,k-1) + n / total;
}
int main(){
cin >> n;
vector<int> a(4,0);
for(int i = 0; i < n; i++){
int x; cin >> x;
a[x]++;
}
cout << fixed << setprecision(16) << f(a[1],a[2],a[3])-1 << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 2e5;
int n, q;
int Suf[N + 5];
struct Node {
int Val, Time;
} R[N + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &R[i].Val);
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int opt, p, x;
scanf("%d", &opt);
if (opt & 1) {
scanf("%d%d", &p, &x);
R[p].Val = x, R[p].Time = i;
} else
scanf("%d", &Suf[i]);
}
for (int i = q - 1; i >= 1; --i) Suf[i] = std::max(Suf[i], Suf[i + 1]);
for (int i = 1; i <= n; ++i)
printf("%d ", std::max(R[i].Val, Suf[R[i].Time + 1]));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
vector<int> arr[26];
string s;
cin >> s;
int len = s.length();
for (int i = 0; i < len; i++) arr[s[i] - 'a'].push_back(i);
string res = "";
int ind = -1;
for (int i = 25; i >= 0; --i) {
for (int j = 0; j < arr[i].size(); ++j) {
if (arr[i][j] > ind) res += (char)('a' + i);
ind = max(ind, arr[i][j]);
}
}
cout << res << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int p = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '-') {
if (p > 0) {
p--;
}
} else {
p++;
}
}
cout << p;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[100005];
long long ans = 0;
int main() {
scanf("%d%d%s", &n, &m, s);
int k = 1;
for (int i = 0; i < (int)(n - 1); ++i)
if (s[i] != s[i + 1]) {
++k;
}
ans = (long long)n * (m - 1) * k;
for (int beg = 0; beg < n - 1;)
if (s[beg] != s[beg + 1]) {
int end = beg + 2;
while (end < n && s[end] == s[end - 2]) ++end;
int sz = end - beg;
ans -= (long long)sz * (sz - 1) / 2;
beg = end - 1;
} else {
++beg;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[200020], d[200020];
long long h1[200020], hr1[200020];
vector<long long> ans;
long long kasumi(long long x, long long y) {
long long z = 1;
while (y) {
if (y & 1) z = z * x % 1000000007;
x = x * x % 1000000007;
y >>= 1;
}
return z;
}
int main() {
scanf("%lld%lld", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i < n; i++) d[i] = a[i + 1] - a[i];
for (int i = 1; i < n; i++) {
h1[i] = (h1[i - 1] + d[i] * kasumi(233, i - 1) % 1000000007) % 1000000007;
}
h1[n] = h1[n - 1];
for (int i = n - 1; i > 0; i--) {
hr1[i] =
(hr1[i + 1] + d[i] * kasumi(233, n - 1 - i) % 1000000007) % 1000000007;
}
hr1[0] = hr1[1];
if ((a[1] + a[n] % m) > a[n]) {
if (hr1[1] == h1[n - 1]) ans.push_back((a[1] + a[n]) % m);
} else {
if (hr1[1] == h1[n - 1]) ans.push_back((a[1] + a[n]) % m);
}
for (int i = 1; i < n; i++) {
if ((a[1] + a[i]) % m == (a[i + 1] + a[n]) % m &&
(a[1] + a[i]) % m >= a[i] && (a[1] + a[i]) % m <= a[i + 1]) {
if (h1[i - 1] == (hr1[0] - hr1[i] + 1000000007) *
kasumi(kasumi(233, (n - i)), 1000000007 - 2) %
1000000007 &&
hr1[i + 1] == (h1[n] - h1[i] + 1000000007) *
kasumi(kasumi(233, i), 1000000007 - 2) % 1000000007)
ans.push_back((a[1] + a[i]) % m);
}
}
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
}
| 2 |
#include <bits/stdc++.h>
namespace IO {
char gc() { return getchar(); }
template <typename Tp>
bool get1(Tp &x) {
bool neg = 0;
char c = gc();
while (c != EOF && (c < '0' || c > '9') && c != '-') c = gc();
if (c == '-') c = gc(), neg = 1;
if (c == EOF) return false;
x = 0;
for (; c >= '0' && c <= '9'; c = gc()) x = x * 10 + c - '0';
if (neg) x = -x;
return true;
}
template <typename Tp>
void printendl(Tp x) {
if (x < 0) putchar('-'), x = -x;
static short a[40], sz;
sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
puts("");
}
} // namespace IO
using IO::get1;
using IO::printendl;
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const int maxn = 100111;
int n, a[maxn], val[maxn];
long long k;
int getbound(int a, long long x) {
int l = 0, r = a + 1, mid;
while (l < r - 1) {
mid = (l + r) / 2;
if (a - 3ll * mid * mid + 3ll * mid - 1 > x)
l = mid;
else
r = mid;
}
return l;
}
long long check(long long x) {
long long ret = 0;
for (int i = 1; i <= n; i++) {
val[i] = getbound(a[i], x);
ret += val[i];
}
return ret;
}
int main() {
get1(n) && get1(k);
for (int i = 1; i <= n; i++) get1(a[i]);
long long lb = -4000000000000000000ll, rb = 10000000000ll, mid;
while (lb < rb - 1) {
mid = (lb + rb) / 2;
if (check(mid) < k)
rb = mid;
else
lb = mid;
}
for (int i = 1; i <= n; i++) {
val[i] = getbound(a[i], rb);
k -= val[i];
}
for (int i = 1; i <= n; i++) {
int nv = getbound(a[i], lb) - val[i];
val[i] += std::min(nv + 0ll, k);
k = std::max(0ll, k - nv);
printf("%d ", val[i]);
}
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
int q;
int main(){
cin >> q;
multiset<int> msa;
for(int i = 0; i < q; i++){
char query;
cin >> query;
if(query == '0'){
int x;
cin >> x;
msa.insert(x);
cout << msa.size() << endl;
}else if(query == '1'){
int x;
cin >> x;
cout << msa.count(x) << endl;
}else if(query == '2'){
int x;
cin >> x;
msa.erase(x);
}else if(query == '3'){
int L, R;
cin >> L >> R;
multiset<int>::iterator itr;
pair<multiset<int>::iterator, multiset<int>::iterator> itr1, itr2;
itr1 = msa.equal_range(L);
itr2 = msa.equal_range(R);
for(itr = itr1.first; itr != itr2.second; itr++){
cout << *itr << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
int n, m;
int x[5010], cnt[1010], l[5010], r[5010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
l[i] = x[i];
cnt[x[i]]++;
}
int Max = 0;
sort(l + 1, l + 1 + n);
for (int i = 1; i <= m; i++) Max = max(Max, cnt[i]);
for (int i = Max + 1; i <= n; i++) r[i - Max] = l[i];
for (int i = 1; i <= Max; i++) r[i + n - Max] = l[i];
int ret = 0;
for (int i = 1; i <= n; i++) ret += (l[i] != r[i]);
cout << ret << endl;
for (int i = 1; i <= n; i++) cout << l[i] << " " << r[i] << endl;
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<math.h>
using namespace std;
const int N=3e5+5;
int n,q,x,a[N];
long long sf[N],sg[N];
void init()
{
int i;
scanf("%d%d",&n,&q);
for(i=1;i<=n;++i) scanf("%d",&a[i]);
for(i=1;i<=n;++i) sf[i]=sf[i-1]+a[i*2-(n&1)];
for(i=1;i<=n;++i) sg[i]=sg[i-1]+a[n+1-i];
}
int fi(int L,int R)
{
int l=1,r=n+1;
while(l<r)
{
int mid=(l+r)>>1;
if(a[mid]>=L) r=mid;
else l=mid+1;
}
int nowl=l;
l=0,r=n;
while(l<r)
{
int mid=(l+r+1)>>1;
if(a[mid]<=R) l=mid;
else r=mid-1;
}
int nowr=l;
return max(nowr-nowl+1,0);
}
int ok(int x,int mid)
{
if(a[mid]<=x) return false;
int tot_x=fi(x*2-a[mid],a[mid]);
int tot_y=n-mid;
return tot_x>tot_y;
}
void work()
{
while(q--)
{
scanf("%d",&x);
int l=1,r=n;
while(l<r)
{
int mid=(l+r+1)>>1;
if(ok(x,mid)) r=mid-1;
else l=mid;
}
int tme=(n+1)>>1;
int now=min(n-l,tme);
printf("%lld\n",sg[now]+sf[tme-now]);
}
}
int main()
{
init();work();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:667772160")
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
vector<pair<int, int> > color[90000 + 7];
int level[300 + 7][300 + 7], row, col, cl, dp[300 + 7][300 + 7];
void bfs(int pre) {
queue<pair<int, int> > q;
int tx, ty;
pair<int, int> tp;
memset(level, -1, sizeof(level));
for (int i = 0; i < color[pre].size(); i++) {
tx = color[pre][i].first;
ty = color[pre][i].second;
level[tx][ty] = dp[tx][ty];
q.push(make_pair(tx, ty));
}
while (!q.empty()) {
tp = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
tx = tp.first + dx[i];
ty = tp.second + dy[i];
if (tx >= 0 and tx < row and ty >= 0 and ty < col and
(level[tx][ty] == -1 or
level[tx][ty] > level[tp.first][tp.second] + 1)) {
level[tx][ty] = level[tp.first][tp.second] + 1;
q.push(make_pair(tx, ty));
}
}
}
}
int main() {
int a, pre, now;
pair<int, int> tp;
scanf("%d %d", &row, &col);
scanf("%d", &cl);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
scanf("%d", &a);
color[a].push_back(make_pair(i, j));
if (a == 1) dp[i][j] = i + j;
if (a == cl) tp = make_pair(i, j);
}
}
for (int i = 2; i <= cl; i++) {
now = color[i].size();
pre = color[i - 1].size();
if (now * pre < row * col) {
int mn = 1800000000;
for (int j = 0; j < now; j++) {
mn = 1800000000;
for (int k = 0; k < pre; k++) {
mn = min(mn, dp[color[i - 1][k].first][color[i - 1][k].second] +
abs(color[i][j].first - color[i - 1][k].first) +
abs(color[i][j].second - color[i - 1][k].second));
}
dp[color[i][j].first][color[i][j].second] = mn;
}
} else {
bfs(i - 1);
for (int j = 0; j < now; j++)
dp[color[i][j].first][color[i][j].second] =
level[color[i][j].first][color[i][j].second];
}
}
deb(dp[tp.first][tp.second]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const uint64_t mod = (1ull << 61) - 1;
const unsigned long long bas = 31;
inline uint64_t mult(uint64_t a, uint64_t b) {
uint64_t l1 = (uint32_t)a, h1 = a >> 32, l2 = (uint32_t)b, h2 = b >> 32;
uint64_t l = l1 * l2, m = l1 * h2 + l2 * h1, h = h1 * h2;
uint64_t ret =
(l & mod) + (l >> 61) + (h << 3) + (m >> 29) + (m << 35 >> 3) + 1;
ret = (ret & mod) + (ret >> 61);
ret = (ret & mod) + (ret >> 61);
return ret - 1;
}
inline unsigned long long add(unsigned long long a, unsigned long long b) {
if ((a += b) >= mod) a -= mod;
return a;
}
inline unsigned long long dec(unsigned long long a, unsigned long long b) {
return add(a, mod - b);
}
const int maxn = 300010;
int n, m, siz[maxn], dfn[maxn], ch[maxn], fa[maxn], tim, top[maxn], dep[maxn],
id[maxn];
char c[maxn];
unsigned long long hs[maxn], ihs[maxn], pw[maxn];
vector<int> v[maxn];
void dfs(int np, int fath) {
siz[np] = 1;
dep[np] = dep[fath] + 1;
fa[np] = fath;
for (int &x : v[np]) {
if (x == fath) continue;
dfs(x, np);
siz[np] += siz[x];
if (!ch[np] || siz[ch[np]] < siz[x]) ch[np] = x;
}
}
void dfs2(int np, int tp) {
dfn[np] = ++tim;
top[np] = tp;
id[tim] = np;
if (ch[np]) dfs2(ch[np], tp);
for (int &x : v[np]) {
if (x == fa[np] || x == ch[np]) continue;
dfs2(x, x);
}
}
void getsection(int x, int y, vector<pair<int, int> > &ret) {
vector<pair<int, int> > v1, v2;
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]]) {
v1.push_back(make_pair(dfn[x], dfn[top[x]]));
x = fa[top[x]];
} else {
v2.push_back(make_pair(dfn[top[y]], dfn[y]));
y = fa[top[y]];
}
}
v1.push_back(make_pair(dfn[x], dfn[y]));
ret = v1;
reverse(v2.begin(), v2.end());
ret.insert(ret.end(), v2.begin(), v2.end());
}
inline unsigned long long gethashg(int l, int r, bool rev) {
if (!rev) return dec(hs[r], mult(hs[l - 1], pw[r - l + 1]));
return dec(ihs[l], mult(ihs[r + 1], pw[r - l + 1]));
}
inline unsigned long long gethash(int l, int r, int len) {
if (l > r)
return gethashg(l - len + 1, l, 1);
else
return gethashg(l, l + len - 1, 0);
}
int main() {
scanf("%d%s", &n, c + 1);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = mult(pw[i - 1], bas);
for (int i = 1, ti, tj; i < n; i++) {
scanf("%d%d", &ti, &tj);
v[ti].push_back(tj);
v[tj].push_back(ti);
}
dfs(1, 0);
dfs2(1, 1);
for (int i = 1; i <= n; i++)
hs[i] = add(mult(hs[i - 1], bas), c[id[i]] - 'a' + 1);
for (int i = n; i >= 1; i--)
ihs[i] = add(mult(ihs[i + 1], bas), c[id[i]] - 'a' + 1);
scanf("%d", &m);
while (m--) {
int p, q, r, s;
scanf("%d%d%d%d", &p, &q, &r, &s);
vector<pair<int, int> > p1, p2;
getsection(p, q, p1);
getsection(r, s, p2);
int clen = 0, i = 0, j = 0;
while (1) {
if (i == p1.size() || j == p2.size()) {
printf("%d\n", clen);
break;
}
int l1 = abs(p1[i].second - p1[i].first) + 1,
l2 = abs(p2[j].second - p2[j].first) + 1;
int mxlen = min(l1, l2);
if (gethash(p1[i].first, p1[i].second, mxlen) !=
gethash(p2[j].first, p2[j].second, mxlen)) {
int l = 1, r = mxlen - 1, ret = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (gethash(p1[i].first, p1[i].second, mid) ==
gethash(p2[j].first, p2[j].second, mid))
ret = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", clen + ret);
break;
}
if (p1[i].first < p1[i].second) {
p1[i].first += mxlen;
if (p1[i].first > p1[i].second) i++;
} else {
p1[i].first -= mxlen;
if (p1[i].first < p1[i].second) i++;
}
if (p2[j].first < p2[j].second) {
p2[j].first += mxlen;
if (p2[j].first > p2[j].second) j++;
} else {
p2[j].first -= mxlen;
if (p2[j].first < p2[j].second) j++;
}
clen += mxlen;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef __int128_t Long;
int main() {
int n, x;
cin >> n >> x;
vector<int> as(n);
for (int i = 0; i < n; i++) {
cin >> as[i];
}
long long ans = 1ll * x * n;
Long nin = 1e18;
vector<long long> sum(n + 1);
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i] + as[i];
}
for (int k = 1; k <= n; k++) {
Long cost = Long(5) * (sum[n] - sum[n - k]);
for (int i = 1; n - k * i > 0; i++) {
cost += (sum[n - k * i] - sum[max(0, n - k * (i + 1))]) * Long(2 * i + 3);
}
nin = min(nin, cost + 1ll * x * k);
}
cout << (long long) nin + ans << endl;
} | 0 |
#include<iostream>
#include<map>
using namespace std;
int main(){
map<int,bool> h;
int q,n,cnt;
cin >> q;
while(q--){
cin >> n;
cnt = 0;
h.clear();
for(;;){
int m = -1, k = 10;
if(h[n]){
cout << -1 << endl;
break;
}
h[n] = true;
if(n<10){
cout << cnt << endl;
break;
}
for(int i=0;i<5;i++){
m = max(m,(n/k)*(n%k));
k *= 10;
}
n = m; cnt++;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int ans = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + (ch ^ 48), ch = getchar();
return ans;
}
inline long long L_read() {
long long ans = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + (ch ^ 48), ch = getchar();
return ans;
}
int dx[5] = {0, -1, 1, 0, 0};
int dy[5] = {0, 0, 0, -1, 1};
struct cz {
long long Time;
bool Initial;
};
cz state[1050][1050];
bool mp[1050][1050];
long long p;
string s;
struct pos {
int x;
int y;
};
pos ww;
inline bool check(int x, int y, int n, int m) {
for (int i = 1; i <= 4; i++) {
int nowx = x + dx[i], nowy = y + dy[i];
if (nowx >= 1 && nowx <= n && nowy >= 1 && nowy <= m)
if (mp[nowx][nowy] == mp[x][y]) return true;
}
return false;
}
int n, m, k, x, y;
bool vis[1050][1050];
queue<pos> qwq;
inline void bfs() {
while (!qwq.empty()) {
int nowx = qwq.front().x;
int nowy = qwq.front().y;
qwq.pop();
for (int i = 1; i <= 4; i++) {
if (nowx + dx[i] >= 1 && nowx + dx[i] <= n && nowy + dy[i] >= 1 &&
nowy + dy[i] <= m) {
if (!vis[nowx + dx[i]][nowy + dy[i]]) {
vis[nowx + dx[i]][nowy + dy[i]] = 1;
state[nowx + dx[i]][nowy + dy[i]].Time = state[nowx][nowy].Time + 1;
ww.x = nowx + dx[i];
ww.y = nowy + dy[i];
qwq.push(ww);
}
}
}
}
}
int main() {
bool ff = 0;
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) {
cin >> s;
for (int j = 0; j < m; j++) {
if (s[j] == '1') state[i][j + 1].Initial = 1, mp[i][j + 1] = 1;
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (check(i, j, n, m)) {
ww.x = i, ww.y = j;
vis[i][j] = 1;
qwq.push(ww);
ff = 1;
}
if (!ff) {
for (int i = 1; i <= k; i++) {
x = read(), y = read(), p = L_read();
cout << mp[x][y] << '\n';
}
return 0;
}
bfs();
for (int i = 1; i <= k; i++) {
x = read(), y = read();
p = L_read();
if (p <= state[x][y].Time) {
cout << state[x][y].Initial << '\n';
continue;
}
if ((p - state[x][y].Time) % 2 == 0)
cout << state[x][y].Initial << '\n';
else {
if (state[x][y].Initial == 0)
cout << 1 << '\n';
else
cout << "0\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int MAXN = 32;
int k[MAXN];
int a[MAXN][MAXN];
int b[MAXN];
int p[MAXN];
int n, r;
long long doit(int u, bool xr) {
long long s = -1ll << 60;
if (u % 2 == 0) {
s = 0;
for (int i = 0; i < (n); ++i) s += (long long)a[u][i] * k[i];
}
if (u == 0) return s;
if (xr) {
for (int i = 0; i < (n); ++i) {
a[u - 1][i] = a[u][i] ^ b[i];
}
s = max(s, doit(u - 1, false));
}
for (int i = 0; i < (n); ++i) {
a[u - 1][i] = a[u][p[i]] + r;
}
s = max(s, doit(u - 1, true));
return s;
}
int main() {
int u;
scanf("%d%d%d", &n, &u, &r);
for (int i = 0; i < (n); ++i) {
scanf("%d", &a[u][i]);
}
for (int i = 0; i < (n); ++i) {
scanf("%d", &b[i]);
}
for (int i = 0; i < (n); ++i) {
scanf("%d", &k[i]);
}
for (int i = 0; i < (n); ++i) {
scanf("%d", &p[i]);
--p[i];
}
long long res = doit(u, true);
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int answ, n, x, q, pi[1000001], fix[2000001];
string st1, st;
vector<pair<int, string>> v[2000001];
pair<int, int> get_ans(int q, int pr, int x) {
pair<int, int> ans;
ans.first = 0;
ans.second = 0;
string s = v[pr][x].second;
for (int i = 1; i <= s.size(); i++) {
while (s[i - 1] - st[q] && q > 0) {
q = pi[q];
if (q + s.size() - i + 1 < st.size() && !v[v[pr][x].first].size()) break;
}
if (st[q] == s[i - 1]) q++;
if (q == st.size()) ans.first++, q = pi[q];
}
ans.second = q;
return ans;
}
void dfs(int x, int q, int pr, int idx) {
if (fix[x]) return;
fix[x] = 1;
pair<int, int> p;
if (pr) {
p = get_ans(q, pr, idx);
answ += p.first;
} else
p.second = q;
for (int i = 0; i < v[x].size(); i++) {
dfs(v[x][i].first, p.second, x, i);
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> st1;
v[x].push_back({i + 1, st1});
}
cin >> st;
pi[1] = 0, q = 0;
for (int i = 2; i <= st.size(); i++) {
while (st[i - 1] - st[q] && q > 0) q = pi[q];
if (st[q] == st[i - 1]) q++;
pi[i] = q;
}
dfs(1, 0, 0, 1);
cout << answ;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, k, l, m, n, t, r, cnt;
int flag = 0;
long long ans = 0, an = 0;
t = 1;
while (t--) {
cin >> n;
string str, str2;
cin >> str >> str2;
long long o = 0, z = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '0') {
z++;
} else {
o++;
}
}
long long cnt1 = 0, cnt2 = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '0' && str2[i] == '0') {
ans += o;
cnt1++;
} else if (str[i] == '1' && str2[i] == '0') {
ans += z;
cnt2++;
}
}
cout << ans - cnt1 * cnt2 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 5e16 + 5;
long long int m, n, q, cn, k, w, pos, tmp1,
size(), mx = 0, tmp, mx1 = -1, b, c, d, mn = infl, k1, p, x, f;
long long int a[1523456];
double d1;
string s, t;
int check(long long int val) {
long long int i;
long long int sm = 0;
for (i = 2; i < 1523456; i++) {
if ((i * i * i) > val) break;
sm = sm + val / (i * i * i);
}
if (sm == m)
return 2;
else if (sm > m)
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("inp.txt", "r")) {
freopen("myfile.txt", "w", stdout);
freopen("inp.txt", "r", stdin);
}
cin >> m;
long long int low = 1, high = infl, mid, ans = -1;
while (low <= high) {
mid = low + (high - low) / 2;
int re = check(mid);
if (re > 0) {
if (re == 2) ans = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 1 << 19;
int A[N], B[N], w[N], inv[N], len, len1, len2, pos[N], res[N], f[N], g[N];
void init() {
int op = len >> 1, k = N / len;
for (int i = 0, j = 0; i < len; ++i, j += k) {
w[i] = f[j];
inv[i] = g[j];
pos[i] = pos[i >> 1] >> 1 | (i & 1 ? op : 0);
}
}
void NTT(int *a, int *omg) {
for (int i = (0); i < (len); ++i)
if (i < pos[i]) swap(a[i], a[pos[i]]);
for (int i = 2; i <= len; i <<= 1) {
int m = i >> 1;
for (int *p = a; p != a + len; p += i) {
for (int j = (0); j < (m); ++j) {
int t = 1ll * omg[len / i * j] * p[j + m] % mod;
p[j + m] = p[j] - t;
if (p[j + m] < 0) p[j + m] += mod;
p[j] += t;
if (p[j] >= mod) p[j] -= mod;
}
}
}
}
int quick(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
int a[N], n, k;
vector<int> quickNTT(int *a, int b, int lenth) {
len = 1;
while (len < lenth) len <<= 1;
res[0] = 1;
for (int i = (1); i < (len); ++i) res[i] = 0;
init();
NTT(res, w);
NTT(a, w);
while (b) {
if (b & 1)
for (int i = (0); i < (len); ++i) res[i] = 1ll * res[i] * a[i] % mod;
for (int i = (0); i < (len); ++i) a[i] = 1ll * a[i] * a[i] % mod;
b >>= 1;
}
vector<int> g;
NTT(res, inv);
int lenni = quick(len, mod - 2);
for (int i = (0); i < (lenth); ++i) g.push_back(1ll * res[i] * lenni % mod);
return g;
}
int main() {
int num = quick(3, (mod - 1) / N), ni = quick(num, mod - 2);
f[0] = g[0] = 1;
for (int i = (1); i < (N); ++i)
f[i] = 1ll * f[i - 1] * num % mod, g[i] = 1ll * g[i - 1] * ni % mod;
scanf("%d%d", &n, &k);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
int cnt = 0;
for (int i = (0); i < (n); ++i)
if (a[i] ^ a[(i + 1) % n]) ++cnt;
A[0] = 1, A[1] = k - 2, A[2] = 1;
vector<int> g = quickNTT(A, cnt, 2 * cnt + 1);
long long ans = 0;
for (int i = (0); i < (g.size()); ++i)
if (i > cnt) ans += g[i];
ans %= mod;
ans = ans * quick(k, n - cnt) % mod;
printf("%lld", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string S;
int main() {
for (int i = 1; i <= 1000; i++) {
S += to_string(i);
}
int n;
std::ios::sync_with_stdio(false);
cin >> n;
cout << S[n - 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 100007;
const int MAX2 = 1000000;
const int MAXD = 20;
const int BASE = 1000000007;
const int MOD = 1000000007;
int n, k, s, t;
vector<int> A, B;
vector<pair<int, int> > C;
bool F(int x) {
int sum = 0;
for (int i = 0; i < (int)B.size(); ++i) {
if (x < B[i]) return 0;
sum += 2 * B[i] - min(x - B[i], B[i]);
}
return sum <= t;
}
int main() {
cin >> n >> k >> s >> t;
vector<pair<int, int> > CC;
for (int i = (0); i < (n); i++) {
int x, y;
scanf("%d%d", &x, &y);
CC.push_back(make_pair(y, x));
}
sort(CC.begin(), CC.end());
for (int i = (0); i < ((int)CC.size()); i++) {
while ((int)C.size() && C.back().second >= CC[i].second) C.pop_back();
if (C.empty() || CC[i].first > C.back().first) C.push_back(CC[i]);
}
for (int i = (0); i < (k); i++) {
int x;
cin >> x;
A.push_back(x);
}
A.push_back(0);
A.push_back(s);
sort(A.begin(), A.end());
A.resize(unique(A.begin(), A.end()) - A.begin());
for (int i = (0); i < ((int)A.size() - 1); i++) {
B.push_back(A[i + 1] - A[i]);
}
int L = 0;
int R = (int)C.size() - 1;
if (!F(C[R].first)) {
cout << -1 << endl;
return 0;
}
while (R - L > 1) {
int X = (L + R) / 2;
if (F(C[X].first))
R = X;
else
L = X;
}
if (F(C[L].first)) R = L;
cout << C[R].second;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int p[100005] = {0};
int used[100005] = {0};
vector<pair<int, int> > ans;
vector<int> v;
int main() {
int n;
cin >> n;
if (n <= 2) {
cout << "0" << endl;
return 0;
}
int lim = n / 2;
for (int i = 3; i <= lim; i += 2) {
if (p[i] == 0) {
int t = i + i;
v.push_back(i);
while (t <= n) {
if (used[t] == 0) v.push_back(t);
p[t] = 1;
t += i;
}
if (v.size() % 2 == 0) {
for (int j = 0; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
} else {
if (v.size() > 1) {
ans.push_back(make_pair(v[0], v[2]));
used[v[0]] = used[v[2]] = 1;
}
for (int j = 3; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
}
v.clear();
}
}
for (int i = 2; i <= n; i += 2) {
if (used[i] == 0) v.push_back(i);
}
if (v.size() % 2 == 0) {
for (int j = 0; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
} else {
if (v.size() > 1) {
ans.push_back(make_pair(v[0], v[2]));
used[v[0]] = used[v[2]] = 1;
}
for (int j = 3; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool ok = false;
unsigned long long k, l, count = 0, z;
cin >> k >> l;
z = k;
while (k <= l) {
if (k == l) {
cout << "YES" << endl;
cout << count << endl;
ok = true;
break;
}
k = k * z;
count++;
}
if (!ok) cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 2;
long long ar[N], grun[N];
multiset<long long> wow;
set<long long> okfine;
signed main() {
long long n, i, j, k, l, r, lef = 0, rig = -1, now = 0, max1 = N;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> ar[i];
}
sort(ar + 1, ar + 1 + n);
set<long long>::iterator ite;
for (i = 0; i <= N; i++) {
okfine.insert(i);
}
for (i = 1; i <= 9e5; i++) {
l = ceil(pow(i, 0.25));
r = min(i - 1, (long long)sqrt(i));
if (l <= r) {
while (rig < r) {
rig++;
wow.insert(grun[rig]);
if (okfine.count(grun[rig])) {
okfine.erase(grun[rig]);
}
}
while (lef < l) {
wow.erase(wow.find(grun[lef]));
if (!wow.count(grun[lef])) {
okfine.insert(grun[lef]);
}
lef++;
}
}
ite = okfine.begin();
grun[i] = *ite;
}
lef = 0;
rig = -1;
wow.clear();
for (i = 0; i <= N; i++) {
if (!okfine.count(i)) {
okfine.insert(i);
}
}
for (i = 1; i <= n; i++) {
l = ceil(pow(ar[i], 0.25));
r = min(ar[i] - 1, (long long)sqrt(ar[i]));
if (l <= r) {
while (rig < r) {
rig++;
wow.insert(grun[rig]);
if (okfine.count(grun[rig])) {
okfine.erase(grun[rig]);
}
}
while (lef < l) {
wow.erase(wow.find(grun[lef]));
if (!wow.count(grun[lef])) {
okfine.insert(grun[lef]);
}
lef++;
}
}
ite = okfine.begin();
now = (now ^ (*ite));
}
if (now == 0) {
cout << "Rublo";
} else {
cout << "Furlo";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b, c, k;
cin >> a >> b >> c >> k;
cout << a + b + c + max(a, max(b, c)) * (int)pow(2, k) - max(a, max(b, c)) << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int NAX=3001;
#define ll long long
int main(){
ll n;
scanf("%lld",&n);
vector<ll> arr(n);
for(int i=0;i<n;i++)scanf("%lld",&arr[i]);
vector<vector<ll> > dp(NAX,vector<ll>(NAX));
for(int i=n-1;i>=0;i--){
for(int j=i;j<n;j++){
if(i==j)
dp[i][j]=arr[i];
else
dp[i][j]=max(arr[i]-dp[i+1][j],arr[j]-dp[i][j-1]);
}
}
printf("%lld",dp[0][n-1]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2>& p) {
out << p.first << ' ' << p.second;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (auto& x : v) in >> x;
return in;
}
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (auto x : v) out << x << ' ';
return out;
}
const long double pi = 2 * asin(1);
int n, m, c, x, s;
vector<vector<int> > fward, bward, nxvis;
vector<int> v;
set<int> st;
bool cycle(int i) {
st.insert(i);
for (int j = 0; j < fward[i].size(); j++) {
if (st.find(fward[i][j]) != st.end()) {
return 1;
}
if (cycle(fward[i][j])) return 1;
}
st.erase(i);
return 0;
}
void bdfs(int i) {
queue<int> q;
q.push(i);
while (!q.empty()) {
i = q.front();
q.pop();
for (int j = 0; j < bward[i].size(); j++) {
if (v[i] != 2) {
if (v[bward[i][j]] == -1) {
v[bward[i][j]] = !v[i];
q.push(bward[i][j]);
} else if (v[bward[i][j]] == v[i]) {
v[bward[i][j]] = 2;
q.push(bward[i][j]);
}
} else if (v[bward[i][j]] != 2) {
v[bward[i][j]] = 2;
q.push(bward[i][j]);
}
}
}
}
stack<int> S;
bool wdfs(int i, int nx) {
nxvis[nx][i] = 1;
S.push(i);
if (nx == 1 && fward[i].size() == 0) return 1;
for (int j = 0; j < fward[i].size(); j++) {
if (!nxvis[!nx][fward[i][j]]) {
if (wdfs(fward[i][j], !nx)) return 1;
S.pop();
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
fward.resize(n);
bward.resize(n);
v.resize(n, -1);
nxvis.resize(2, vector<int>(n));
for (register int i = 0; i < n; i++) {
cin >> c;
for (register int j = 0; j < c; j++) {
cin >> x;
fward[i].push_back(x - 1);
bward[x - 1].push_back(i);
}
}
for (register int i = 0; i < n; i++) {
if (fward[i].empty()) {
if (v[i] == -1) v[i] = 1;
if (v[i] == 0) v[i] = 2;
bdfs(i);
}
}
cin >> s;
s--;
if (v[s] == 2 || v[s] == 0) {
cout << "Win\n";
wdfs(s, 0);
vector<int> v;
while (!S.empty()) {
v.push_back(S.top());
S.pop();
}
for (int i = v.size() - 1; i > -1; i--) cout << v[i] + 1 << ' ';
return 0;
}
if (cycle(s)) {
cout << "Draw";
return 0;
}
cout << "Lose";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e6 + 5;
const long long inf = 1e10;
const long long mod = 1e9 + 7;
long long n;
long long x[maxN];
long long a, b;
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> x[i];
cin >> a >> b;
sort(x + 1, x + 1 + n);
n = unique(x + 1, x + 1 + n) - (x + 1);
long long res = 0;
while (a > b) {
long long next = a - 1;
for (long long i = 1; i <= n; i++) {
long long tmp = a - a % x[i];
if (tmp < b) {
x[i--] = x[--n];
} else if (tmp < next)
next = tmp;
}
a = next;
res++;
}
cout << res;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
using i64 = long long int;
i64 gcd(i64 m, i64 n) {
return (n == 0 ? m : gcd(n, m % n));
}
i64 lcm(i64 m, i64 n) {
return m / gcd(m, n) * n;
}
int main(){
int n;
cin >> n;
i64 ans = 1;
for(int i=0;i<n;++i){
i64 a;
cin >> a;
ans = lcm(ans, a);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define fi first
#define sd second
#define ll long long
using namespace std;
const int maxn = 200200;
const int base = 1e9+7;
const ll inf = 1145141919;
pair<ll, int> p[maxn],q[maxn];
int n,l[maxn],r[maxn],id[maxn],t[maxn],f[maxn];
void update(int i,int k) {
while (i<=n+1) {
t[i] = (t[i]+k)%base;
i+=(i&-i);
}
}
int get(int i) {
int res=0;
while (i>0) {
res = (res+t[i])%base;
i-=(i&-i);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
// freopen("in.txt","r",stdin);
cin>>n;
for (int i=1;i<=n;i++) {
ll x;
int v;
cin>>x>>v;
p[i] = make_pair(x,v);
}
sort(p+1,p+n+1);
for (int i=1;i<=n;i++) {
ll s;
s = p[i].fi + inf*p[i].sd;
q[i] = make_pair(s,i);
}
sort(q+1,q+n+1);
//cout<<"fuck"<<endl;
for (int i=1;i<=n;i++) id[q[i].sd] = i;
// for (int i=1;i<=n;i++) cout<<id[i]<<" ";
for (int i=1;i<=n;i++) {
r[i] = id[i];
if (i>1) r[i] = max(r[i],r[i-1]);
}
for (int i=n;i>=1;i--) {
l[i] = id[i];
if (i<n) l[i] = min(l[i],l[i+1]);
}
//cout<<"fuck"<<endl;
update(1,1);
//cout<<get(4)<<"fd"<<endl;
for (int i=1;i<=n;i++) {
//cout<<l[i]<<" "<<r[i];
int sum = (get(r[i]+1) - get(l[i]-1) + base)%base;
f[r[i]] = (f[r[i]] + sum)%base;
// cout<<sum<<endl;
update(r[i]+1,sum);
}
cout<<f[n]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
int in[20000];
int out[20000];
vector<int> v[20000];
vector<int> e[20000];
bool vis[20000];
int ans = 1e9;
int tap = 0;
int flag;
void dfs(int s) {
vis[s] = true;
for (int i = 0; i < v[s].size(); i++) {
int now = v[s][i];
if (vis[now] == false) {
ans = min(ans, e[s][i]);
if (in[now] == 1 && out[now] == 0) {
flag = 1;
tap = now;
}
dfs(now);
}
}
}
int main() {
int n, p;
cin >> n >> p;
for (int i = 0; i < p; i++) {
int a, b, c;
cin >> a >> b >> c;
v[a].push_back(b);
e[a].push_back(c);
in[b]++;
out[a]++;
}
vector<int> tank;
for (int i = 1; i <= n; i++) {
if (out[i] == 1 && in[i] == 0) {
tank.push_back(i);
}
}
vector<pair<int, pair<int, int> > > res;
for (int i = 0; i < tank.size(); i++) {
int t = tank[i];
flag = 0;
ans = 1e9;
dfs(t);
if (flag) {
res.push_back(make_pair(t, make_pair(tap, ans)));
}
}
sort(res.begin(), res.end());
cout << res.size() << endl;
for (int i = 0; i < res.size(); i++) {
cout << res[i].first << " " << res[i].second.first << " "
<< res[i].second.second << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define P pair<int, int>
using namespace std;
const int INF=1e5;
int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
int main(){
int h,w,a[1009][1009];
string s[1009];
cin >> h >> w;
memset(a, -1, sizeof(a));
for(int i=0;i<h;i++)cin >> s[i];
queue<P> q;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(s[i][j]=='#'){
a[i][j]=0;
q.push(P(i,j));
}
}
}
int mx=0;
while(!q.empty()){
P p=q.front();q.pop();
int ci=p.first;
int cj=p.second;
for(int i=0;i<4;i++){
int ni=ci+dy[i];
int nj=cj+dx[i];
if(!(0<=ni&&ni<h&&0<=nj&&nj<w))continue;
if(a[ni][nj]==-1){
a[ni][nj]=a[ci][cj]+1;
mx = max(mx, a[ni][nj]);
q.push(P(ni, nj));
}
}
}
cout << mx << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, sum, cnt, ans, a[100005], c[100005];
pair<int, int> edges[100005];
vector<pair<int, int> > v[100005];
void dfs(int x, int paint) {
if (c[x]) {
if (c[x] != paint) {
printf("NO\n");
exit(0);
}
return;
}
c[x] = paint;
for (auto y : v[x]) {
if (y.second)
dfs(y.first, paint);
else
dfs(y.first, 3 - paint);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d", &x);
while (x--) {
scanf("%d", &y);
if (edges[y].first)
edges[y].second = i;
else
edges[y].first = i;
}
}
for (int i = 1; i <= n; i++) {
v[edges[i].first].push_back({edges[i].second, a[i]});
v[edges[i].second].push_back({edges[i].first, a[i]});
}
for (int i = 1; i <= m; i++) {
if (!c[i]) {
dfs(i, 1);
}
}
printf("YES\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y >= 1) {
if (y % 2) res = (res * x) % p;
x = ((x % p) * (x % p)) % p;
y /= 2;
}
return res;
}
void solve() {
long long int n, m;
cin >> n >> m;
cout << power(power(2, m, 1000000007) - 1, n, 1000000007) << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) {
solve();
}
}
| 2 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,cnt,la,a[200010][2],rt;
char s[200010];
void build(int x,int y){
a[++cnt][0]=x;a[cnt][1]=y;
}
int main(){
int i,j;
scanf("%s",s+1);
n=strlen(s+1);
for(i=1;i<n;i++)if(s[i]!=s[n-i])return puts("-1"),0;
if(s[1]=='0'||s[n]=='1')return puts("-1"),0;
m=1;rt=1;la=1;
for(i=2;i<=n;i++)if(s[i]=='1'){
build(rt,++m);rt=m;
for(j=1;j<i-la;j++)build(rt,++m);la=i;
}
build(rt,++m);
rt=m;
for(i=m+1;i<=n;i++)build(rt,i);
for(i=1;i<n;i++)printf("%d %d\n",a[i][0],a[i][1]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, mx = 1e3 + 1;
long long inv[mx];
void precomp(int n) {
inv[1] = 1;
for (int i = 2; i <= n; ++i) inv[i] = mod - mod / i * inv[mod % i] % mod;
}
long long bin_exp(long long a, long long x) {
long long res = 1;
while (x > 0) {
if (x % 2) res = res * a % mod;
a = a * a % mod;
x /= 2;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
precomp(mx - 1);
int t;
cin >> t;
while (t--) {
long long n, m, rb, cb, rd, cd, x = 0, C = 1, p, sth = 0, dr, dc;
cin >> n >> m >> rb >> cb >> rd >> cd >> p;
long long r = rb, c = cb, idr = dr = (r == n ? -1 : 1),
idc = dc = (c == m ? -1 : 1);
do {
if (r == rd || c == cd) {
sth = (sth + x * p % mod * inv[100] % mod * C) % mod;
C = C * (100 - p) % mod * inv[100] % mod;
}
++x;
r += dr;
c += dc;
if (r == n)
dr = -1;
else if (r == 1)
dr = 1;
if (c == m)
dc = -1;
else if (c == 1)
dc = 1;
} while (r != rb || c != cb || dr != idr || dc != idc);
long long ans = (C * x + sth) % mod * bin_exp(1 - C + mod, mod - 2) % mod;
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int mod = 1000000007;
int p, k;
bool us[1 << 20];
void go(int v) {
if (us[v]) return;
us[v] = 1;
go(((long long)v * k) % p);
}
int main() {
scanf("%d %d", &p, &k);
if (k == 1) {
long long ans = 1;
for (int i = 0; i < p; ++i) {
ans = (ans * p) % mod;
}
printf("%lld\n", ans);
return 0;
}
if (k == 0) {
long long ans = 1;
for (int i = 0; i + 1 < p; ++i) {
ans = (ans * p) % mod;
}
printf("%lld\n", ans);
return 0;
}
long long ans = 1;
memset(us, 0, sizeof(us));
for (int i = 1; i < p; ++i) {
if (!us[i]) {
go(i);
ans = (ans * p) % mod;
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long pre[105];
long long nxt[105];
int main() {
long long n;
cin >> n;
long long cur = 0;
vector<long long> v[n + 1];
for (long long i = 0; i <= n; i++) {
v[i].push_back(0);
}
for (long long i = 0; i < n; i++) {
long long t1;
cin >> t1;
long long l = 0;
long long r = n - 1;
long long pos = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (v[mid].back() < t1) {
pos = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
v[pos].push_back(t1);
}
for (long long i = 0; i < n; i++) {
for (long long j = 1; j < v[i].size(); j++) {
cout << v[i][j] << " ";
}
cout << "\n";
if (v[i + 1].size() == 1) {
break;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cant[26][26];
int main() {
string s;
cin >> s;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string st;
cin >> st;
int i1 = (int)(st[0] - 'a');
int i2 = (int)(st[1] - 'a');
cant[i1][i2] = cant[i2][i1] = true;
}
int ret = 0, count1 = 1, count2 = 0;
char last = s[0], last2 = ' ';
for (int i = 1; i < s.size(); ++i) {
if (last == s[i]) {
++count1;
continue;
} else if (last2 == s[i]) {
++count2;
continue;
} else if (count2 == 0) {
last2 = s[i];
int i1 = (int)(last - 'a');
int i2 = (int)(last2 - 'a');
if (cant[i1][i2]) {
++count2;
} else {
last = last2;
last2 = ' ';
count1 = 1;
count2 = 0;
}
} else {
ret += min(count1, count2);
last = s[i];
last2 = ' ';
count1 = 1;
count2 = 0;
}
}
ret += min(count1, count2);
cout << ret << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
set<string> visited_;
string rotate_left(string &str) {
string ret = str;
ret[0] = str[1];
ret[1] = str[2];
ret[2] = str[3];
ret[3] = str[0];
return ret;
}
string rotate_front(string &str) {
string ret = str;
ret[4] = str[1];
ret[1] = str[5];
ret[5] = str[3];
ret[3] = str[4];
return ret;
}
bool visited(string &str) {
if (visited_.count(str) > 0) {
return true;
}
visited_.insert(str);
string t = rotate_left(str);
if (visited_.count(t) == 0) {
visited(t);
}
t = rotate_front(str);
if (visited_.count(t) == 0) {
visited(t);
}
return false;
}
bool solve() {
string colors;
if (!(cin >> colors)) {
return false;
}
visited_.clear();
int ans = 0;
for (int i = 0; i < 6 * 6 * 6 * 6 * 6 * 6; ++i) {
string cur = colors;
set<int> was;
int c = i;
for (int j = 0; j < 6; ++j) {
cur[j] = colors[c % 6];
was.insert(c % 6);
c /= 6;
}
if (was.size() != 6) {
continue;
}
if (!visited(cur)) {
++ans;
}
}
printf("%d\n", ans);
return true;
}
int main() {
ios_base::sync_with_stdio(false);
while (solve())
;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int tu[15][15];
bool test(int x, int y, int n, int m, int g) {
int i, j, sum = 0;
for (i = x; i < x + n; i++) {
for (j = y; j < y + m; j++) {
if (tu[i][j] == 1) {
sum++;
}
}
}
if (sum >= g) {
return true;
} else {
return false;
}
}
int main() {
int r, c, g, k, i, j, m, n, a, b;
scanf("%d%d%d%d", &r, &c, &g, &k);
int sum = 0;
for (i = 0; i < g; i++) {
scanf("%d%d", &a, &b);
tu[a - 1][b - 1] = 1;
}
for (i = 1; i <= r; i++) {
for (j = 1; j <= c; j++) {
for (m = 0; m < r; m++) {
for (n = 0; n < c; n++) {
if (m + i - 1 < r && n + j - 1 < c) {
if (test(m, n, i, j, k)) {
sum++;
}
}
}
}
}
}
printf("%d\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 2e5 + 100;
int expo(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = (1ll * res * a) % 998244353;
a = (1ll * a * a) % 998244353;
b >>= 1;
}
return res % 998244353;
}
void solve() {
string a;
cin >> a;
vector<vector<int> > dp((int)a.size(), vector<int>((int)a.size()));
vector<int> prefix((int)a.size() + 5);
for (int i = 0; i < (int)a.size(); i++) {
prefix[i + 1] = prefix[i];
prefix[i + 1] += a[i] == '?';
}
for (int k = 2; k < (int)a.size() + 1; k++) {
for (int i = 0; i < (int)a.size() - k + 1; i++) {
int j = i + k - 1;
if (a[i] != '(') {
dp[i][j] += dp[i + 1][j];
dp[i][j] %= 998244353;
}
if (a[j] != ')') {
dp[i][j] += dp[i][j - 1];
dp[i][j] %= 998244353;
}
if (a[i] != '(' and a[j] != ')') {
dp[i][j] -= dp[i + 1][j - 1];
dp[i][j] += 998244353;
dp[i][j] %= 998244353;
}
if (a[i] != ')' and a[j] != '(') {
dp[i][j] += dp[i + 1][j - 1];
dp[i][j] %= 998244353;
dp[i][j] += expo(2, prefix[j] - prefix[i + 1]);
dp[i][j] %= 998244353;
}
}
}
cout << dp[0][(int)a.size() - 1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
while(1){
int a,c=0;
cin>>a;
if(a==0) break;
for(int n=1;n<=a;n++){
if(n%2==1 && a%n==0){
c++;
}else if(n%2==0 && a%n==n/2){
c++;
}
}
cout<<(c-1)/2<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, a[1005], ans, min, min2;
a[1004] = 100000;
cin >> t;
for (int i = 0; i < t; i++) {
scanf("%d%d", &m, &n);
ans = 0;
min = 1004;
min2 = 1004;
for (int j = 0; j < m; j++) {
scanf("%d", &a[j]);
ans += a[j];
if (a[j] < a[min])
min = j;
else if (a[j] < min2)
min2 = j;
}
if (n < m || m <= 2) {
cout << "-1" << endl;
continue;
}
ans *= 2;
ans += (n - m) * (a[min] + a[min2]);
cout << ans << endl;
for (int i = 1; i < m; i++) {
printf("%d %d\n", i, i + 1);
}
printf("%d %d\n", m, 1);
for (int i = 0; i < n - m; i++) {
printf("%d %d\n", min + 1, min2 + 1);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool updateMin(T& a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
inline bool updateMax(T& a, T b) {
return a < b ? a = b, 1 : 0;
}
inline int nextInt() {
int x;
scanf("%d", &x);
return x;
}
inline long long nextI64() {
long long d;
cin >> d;
return d;
}
inline char nextChr() {
scanf(" ");
return getchar();
}
inline string nextStr() {
string s;
cin >> s;
return s;
}
inline double nextDbf() {
double x;
scanf("%lf", &x);
return x;
}
inline long long nextlld() {
long long d;
scanf("%lld", &d);
return d;
}
inline long long next64d() {
long long d;
scanf("%I64d", &d);
return d;
}
int main() {
string s1 = nextStr();
string s2 = nextStr();
int l, r, l1 = s1.size(), l2 = s2.size();
for (int i = 0, p = 0; i < l2 && p < l1; i++) {
if (s1[p] == s2[i]) p++;
if (p > l1 - 1) l = i;
}
for (int i = l2 - 1, p = l1 - 1; i >= 0 && p >= 0; i--) {
if (s1[p] == s2[i]) p--;
if (p < 0) r = i;
}
printf("%d\n", max(r - l, 0));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll<<50;
template<typename T>
void printv(const vector<T>& s) {
for(int i=0;i<(int)(s.size());++i) {
cout << s[i];
if(i == (int)(s.size())-1) cout << endl;
else cout << " ";
}
}
int main () {
cin.tie(0);
cout << fixed << setprecision(10);
while(1) {
string s; cin >> s;
if(s == "#") break;
int sz = s.size();
int a, b, c, d; cin >> a >> b >> c >> d;
a--; b--; c--; d--;
int h = 0, w = 0;
bool init = true;
for(int i=0;i<sz;++i) {
if(init && s[i] == 'b') {
w++;
} else if(s[i] == '/') {
init = false;
h++;
} else if(init && s[i] != 'b') {
w += (int)(s[i] - '0');
}
}
h++;
vector<vector<char>> v(h, vector<char>(w));
int posh = 0, posw = 0;
for(int i=0;i<sz;++i) {
if(s[i] == 'b') {
v[posh][posw] = 'b';
posw++;
} else if(s[i] == '/') {
posw = 0;
posh++;
} else {
int cnt = (int)(s[i] - '0');
while(cnt > 0) {
v[posh][posw] = '.';
posw++;
cnt--;
}
}
}
v[a][b] = '.';
v[c][d] = 'b';
for(int i=0;i<h;++i) {
int cnt = 0;
for(int j=0;j<w;++j) {
if(v[i][j] == 'b') {
if(cnt != 0) cout << cnt;
cnt = 0;
cout << "b";
} else {
cnt++;
}
}
if(cnt != 0) cout << cnt;
cnt = 0;
if(i != h-1) cout << '/';
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 100000007;
const int MAXN = 1000000;
const int inf = 0x3f3f3f3f;
int n, a[200005], b[200005];
int book[200005];
bool check(int x) {
memset(book, 0, sizeof(book));
for (int i = 1; i <= n; i++) {
if (a[i] == 1) book[i] = 0;
}
if (x <= n) {
int t = 1;
for (int i = x + 1; i <= n; i++) {
if (b[i] == t)
t++;
else
return false;
}
for (int i = 1; i <= x; i++) {
if (b[i] != 0) book[b[i]] = i;
}
int now = 0;
for (int i = n - x + 1; i <= n; i++) {
if (book[i] <= now)
now++;
else
return false;
}
return true;
} else {
for (int i = 1; i <= x - n; i++) {
if (b[i] != 0) book[b[i]] = 0;
}
int t = 0;
for (int i = x - n + 1; i <= n; i++) {
t++;
if (b[i] != 0) book[b[i]] = t;
}
int now = 0;
for (int i = 1; i <= n; i++) {
if (book[i] <= now)
now++;
else
return false;
}
return true;
}
}
int main() {
scanf("%d", &n);
int pos1 = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 1) pos1 = 0;
if (x != 0) a[x] = 1;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
if (b[i] == 1) pos1 = i;
}
int r = 2 * n + 10, l = n;
if (pos1 != 0 && check(pos1 - 1)) {
printf("%d\n", pos1 - 1);
return 0;
} else {
while (r > l + 1) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (check(l))
printf("%d\n", l);
else
printf("%d\n", r);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
auto clk = clock();
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
const int dx8[] = {-1, -1, -1, 0, 1, 1, 1, 0},
dy8[] = {-1, 0, 1, 1, 1, 0, -1, -1};
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long Gcd(long long a, long long b) {
if (a % b == 0) return b;
return Gcd(b, a % b);
}
long long Max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long Min(long long a, long long b) {
if (a < b) return a;
return b;
}
void printvector(std::vector<long long> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << "" << endl;
}
void printarray(long long a[], long long n) {
for (long long i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << "" << endl;
}
long long findlcm(vector<long long> arr, long long n) {
long long ans = arr[0];
for (int i = 1; i < n; i++) ans = (((arr[i] * ans)) / (Gcd(arr[i], ans)));
return ans;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long a, long long m) {
long long x, y;
long long g = gcdExtended(a, m, &x, &y);
if (g != 1)
return -1;
else {
long long res = (x % m + m) % m;
return res;
}
}
long long inverse(long long x, long long mod) { return power(x, mod - 2, mod); }
vector<long long> primeFactors(long long n) {
vector<long long> v;
while (n % 2 == 0) {
v.push_back(2);
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
v.push_back(i);
n = n / i;
}
}
if (n > 2) v.push_back(n);
return v;
}
long long lowerbound(long long k, vector<long long> v) {
long long l = 0;
long long size = v.size();
long long r = size - 1;
long long mid;
while (l <= r) {
mid = (l + r) / 2;
if (v[mid] < k)
l = mid + 1;
else {
r = mid - 1;
}
}
return l;
}
long long upperbound(long long k, vector<long long> v) {
long long l = 0;
long long size = v.size();
long long r = size - 1;
long long mid;
while (l <= r) {
mid = (l + r) / 2;
if (v[mid] > k)
r = mid - 1;
else {
l = mid + 1;
}
}
return l;
}
long long C[2001][2000];
void binomialCoeff(long long n, long long k) {
long long i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= k; j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] % 1000000007 + C[i - 1][j] % 1000000007) %
1000000007;
}
}
}
string convertToNewString(const string &s) {
string newString = "@";
for (long long i = 0; i < s.size(); i++) {
newString += "#" + s.substr(i, 1);
}
newString += "#$";
return newString;
}
string longestPalindromeSubstring(const string &s) {
string Q = convertToNewString(s);
long long c = 0, r = 0;
long long P[Q.size() + 4];
memset(P, 0, sizeof(P));
for (long long i = 1; i < Q.size() - 1; i++) {
long long iMirror = c - (i - c);
if (r > i) {
P[i] = min(r - i, P[iMirror]);
}
while (Q[i + 1 + P[i]] == Q[i - 1 - P[i]]) {
P[i]++;
}
if (i + P[i] > r) {
c = i;
r = i + P[i];
}
}
int maxPalindrome = 0;
int centerIndex = 0;
for (int i = 1; i < Q.size() - 1; i++) {
if (P[i] > maxPalindrome) {
maxPalindrome = P[i];
centerIndex = i;
}
}
cout << maxPalindrome << "\n";
return s.substr((centerIndex - 1 - maxPalindrome) / 2, maxPalindrome);
}
long long spf[100010];
void sieve() {
spf[1] = 1;
for (int i = 2; i < 100010; i++) spf[i] = i;
for (int i = 4; i < 100010; i += 2) spf[i] = 2;
for (int i = 3; i * i < 100010; i++) {
if (spf[i] == i) {
for (int j = i * i; j < 100010; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
long long binarySearch(long long arr[], long long l, long long r, long long x) {
if (r >= l) {
long long mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
const long long N = 100000;
long long n;
long long tree[2 * N];
void build(long long arr[]) {
for (long long i = 0; i < n; i++) {
tree[n + i] = arr[i];
}
for (long long i = n - 1; i > 0; --i) {
tree[i] = tree[i << 1] + tree[i << 1 | 1];
}
}
void updateTreeNode(long long p, long long value) {
tree[p + n] = value;
p = p + n;
for (long long i = p; i > 1; i >>= 1) {
tree[i >> 1] = tree[i] + tree[i ^ 1];
}
}
long long query(long long l, long long r) {
long long res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
res += tree[l++];
}
if (r & 1) {
res += tree[--r];
}
}
return res;
}
vector<long long> shortPath(vector<pair<long long, long long> > v[],
long long src, long long V = 0) {
set<pair<long long, long long> > setds;
long long sizee = V;
long long IN = LLONG_MAX;
vector<long long> dist(sizee, IN);
vector<bool> vis(sizee, false);
setds.insert(make_pair(0, src));
dist[src] = 0;
while (!setds.empty()) {
pair<long long, long long> tmp = *(setds.begin());
setds.erase(setds.begin());
long long u = tmp.second;
if (vis[u]) continue;
vis[u] = true;
vector<pair<long long, long long> >::iterator i;
for (auto i = v[u].begin(); i != v[u].end(); ++i) {
long long v = (*i).first;
long long weight = (*i).second;
if (dist[v] > dist[u] + weight) {
if (dist[v] != LLONG_MAX)
setds.erase(setds.find(make_pair(dist[v], v)));
dist[v] = dist[u] + weight;
setds.insert(make_pair(dist[v], v));
}
}
}
return dist;
}
long long root(long long a[], long long r) {
if (a[r] == r) {
return r;
} else {
long long x = root(a, a[r]);
a[r] = x;
return x;
}
}
void unio(long long a[], long long size[], long long x, long long y) {
x = root(a, x);
y = root(a, y);
if (x == y) {
return;
}
if (size[x] >= size[y]) {
a[y] = x;
size[x] += size[y];
} else {
a[x] = y;
size[y] += size[x];
}
}
void dfs(std::vector<long long> v[], long long s, bool visited[]) {
visited[s] = true;
for (long long i = 0; i < v[s].size(); ++i) {
if (!visited[v[s][i]]) {
dfs(v, v[s][i], visited);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long txt = 1;
while (txt--) {
cin >> n;
long long l, r;
cin >> l >> r;
long long op = 0;
for (long long i = 1; i <= l; i++) {
op += pow(2, i - 1);
}
op += (n - l);
cout << op << " ";
op = 0;
for (long long i = 1; i <= r; i++) {
op += pow(2, i - 1);
}
op += (n - r) * (pow(2, r - 1));
cout << op << endl;
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
map<int,int> a;
for(int i = 0; i < n; ++i) {
int x;
cin >> x;
++a[x];
}
int ans = 0;
vector<int> v;
for(auto i : a) v.push_back(i.second);
sort(v.begin(), v.end());
for(int i = 0; i < (int)v.size() - k; ++i) {
ans += v[i];
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, Q, a[N], deg[N];
long long t[N], sum[N];
multiset<long long> s[N], all;
long long calc(int x) { return sum[x] + (t[x] - t[x] / (deg[x] + 1) * deg[x]); }
void Del(int x) {
if (s[x].size()) {
long long selfv = t[x] / (deg[x] + 1);
all.erase(all.find(selfv + *s[x].begin()));
all.erase(all.find(selfv + *s[x].rbegin()));
}
}
void Ins(int x) {
if (s[x].size()) {
long long selfv = t[x] / (deg[x] + 1);
all.insert(selfv + *s[x].begin());
all.insert(selfv + *s[x].rbegin());
}
}
void del(int f, int x) { s[f].erase(s[f].find(calc(x))); }
void ins(int f, int x) { s[f].insert(calc(x)); }
void modify(int x, int v) {
if (a[x] == v) return;
int f = a[x], ff = a[f], fff = a[ff];
Del(fff), Del(ff), Del(f);
del(fff, ff), del(ff, f), del(f, x);
sum[f] -= t[x] / (deg[x] + 1);
sum[ff] -= t[f] / (deg[f] + 1);
--deg[f];
sum[ff] += t[f] / (deg[f] + 1);
ins(fff, ff), ins(ff, f);
Ins(fff), Ins(ff), Ins(f);
f = v, ff = a[f], fff = a[ff];
Del(fff), Del(ff), Del(f);
del(fff, ff), del(ff, f);
sum[ff] -= t[f] / (deg[f] + 1);
++deg[f];
sum[ff] += t[f] / (deg[f] + 1);
sum[f] += t[x] / (deg[x] + 1);
ins(f, x), ins(ff, f), ins(fff, ff);
Ins(f), Ins(ff), Ins(fff);
a[x] = f;
}
int main() {
cin >> n >> Q;
for (int i = 1; i <= n; i++) scanf("%lld", &t[i]);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), ++deg[i], ++deg[a[i]];
for (int i = 1; i <= n; i++) sum[a[i]] += t[i] / (deg[i] + 1);
for (int i = 1; i <= n; i++) ins(a[i], i);
for (int i = 1; i <= n; i++) Ins(i);
while (Q--) {
int op, x, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &v);
modify(x, v);
} else if (op == 2) {
scanf("%d", &x);
printf("%lld\n", calc(x) + t[a[x]] / (deg[a[x]] + 1));
} else {
printf("%lld %lld\n", *all.begin(), *all.rbegin());
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
vector<pair<long long, long long>> gr[N];
long long dist[N];
long long vis[N];
void djikstra(long long node) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
for (long long i = 0; i < N; i++) dist[i] = LLONG_MAX;
dist[node] = 0;
pq.push({0, node});
while (!pq.empty()) {
long long u = pq.top().second;
pq.pop();
if (vis[u]) continue;
vis[u] = 1;
for (auto it : gr[u]) {
if (dist[it.first] > dist[u] + it.second) {
dist[it.first] = dist[u] + it.second;
pq.push({dist[it.first], it.first});
}
}
}
}
vector<pair<pair<long long, long long>, long long>> edges;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, s;
cin >> n >> m >> s;
for (long long i = 0; i < m; i++) {
long long x, y, z;
cin >> x >> y >> z;
gr[x].push_back({y, z});
gr[y].push_back({x, z});
edges.push_back({{x, y}, z});
}
djikstra(s);
long long l;
cin >> l;
long long ans = 0;
for (long long i = 1; i <= n; i++)
if (dist[i] == l) ans++;
for (auto it : edges) {
long long u = it.first.first;
long long v = it.first.second;
long long w = it.second;
set<long long> st;
long long temp = 0;
if (dist[u] < l && dist[u] + w > l) {
if (dist[v] + w - l >= -dist[u] + l) temp++;
}
if (dist[v] < l && dist[v] + w > l) {
if (dist[u] + w - l >= -dist[v] + l) temp++;
}
if (temp == 2 && 2 * l == w + dist[u] + dist[v]) temp--;
ans += temp;
}
cout << ans;
}
| 4 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define int long long
int dx[] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[] = {0, 1, 0, -1, 1, 1, -1, -1};
/*
#define cin ifs
#define cout ofs
ifstream ifs("in.txt");
ofstream ofs("out.txt");
//*/
// DPを用いて最長増加部分列問題を解く
const int MAX_N = 200000;
const int INF = 1e11;
int n = 0;
int a[MAX_N];
int dp[MAX_N];
int solve() {
fill(dp, dp + n, INF);
for (int i = 0; i < n; i++) {
*lower_bound(dp, dp + n, a[i]) = a[i];
}
return lower_bound(dp, dp + n, INF) - dp;
}
int x_1, y_1, x_2, y_2, N;
int X[200000], Y[200000];
int idx[200000];
signed main() {
cin >> x_1 >> y_1 >> x_2 >> y_2 >> N;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i];
if (abs(x_1 - x_2) == abs(x_1 - X[i]) + abs(x_2 - X[i]) &&
abs(y_1 - y_2) == abs(y_1 - Y[i]) + abs(y_2 - Y[i])) {
idx[n] = i;
n++;
}
}
sort(idx, idx + n,
[](int l, int r) { return abs(x_1 - X[l]) < abs(x_1 - X[r]); });
for (int i = 0; i < n; i++) {
a[i] = abs(y_1 - Y[idx[i]]);
}
int s = solve();
double ans = 100 * (abs(x_1 - x_2) + abs(y_1 - y_2)) - (20 - 5 * M_PI) * s;
if (min(abs(x_1 - x_2), abs(y_1 - y_2)) + 1 == s) {
ans += 5 * M_PI;
}
cout << fixed << setprecision(15) << ans << endl;
} | 0 |
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
double a,an,sum;
while(cin>>a){
an=a*2;
sum=0;
for(int i=0;i<5;i++){
sum+=a+an;
a=an/3;
an=a*2;
}
printf("%.8lf\n",sum);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[102];
int main(){
cin >> n; int ans = 1e9;
for(int i = 1; i <= n; ++i)
cin >> a[i];
for(int i = 0; i <= 100; ++i){
int sum = 0;
for(int j = 1; j <= n; ++j)
sum += (a[j] - i) * (a[j] - i);
ans = min(ans, sum);
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int p = 777777777;
int a1[] = {
0, 412133651, 386543325, 139952108, 289303402, 102404925, 317067177,
396414708, 80515854, 663739304, 317300809, 228877044, 493725043, 715317967,
490300965, 315527373, 743539734, 488329191, 553627998, 533025234, 242583957,
706116537, 614109258, 645447222, 523195911, 492109128, 722623041, 111085128,
766395126, 654378921, 691964847, 496688157, 399056049, 654363234, 102052314,
191720088, 473910948, 259736526, 332840025, 388047555, 665791056, 627111387,
139696515, 441456687, 443032569, 283264821, 771641703, 452641455, 511306362,
117572859, 127701891, 721298331, 176520078, 357242229, 611296308, 696994956,
405628839, 429224274, 465336054, 695091546, 689828796, 574648641, 351220905,
507964023, 675326610, 517248963, 453528621, 220301928, 494463186, 681789969,
339589656, 44524053, 417125457, 339589404, 747135963, 341780733, 734158215,
396817281, 21997836, 5728464, 147611205, 456248898, 714128667, 377654949,
3862068, 128418948, 589390074, 304947090, 11703825, 228266073, 127304142,
429215724, 361541124, 521572968, 468358191, 341231688, 65323503, 613778508,
15985323, 291661029, 410970006, 591638112, 349541550, 89967528, 224922159,
361094166, 584206074, 640051812, 324264456, 652625388, 693768537, 11740617,
309238398, 211085469, 194905872, 639416484, 110110707, 296645895, 748118511,
131177718, 511142751, 775975599, 421403409, 475528473, 434685258, 1768977,
80301375, 708023862, 569195676, 56238084, 632887668, 88089750, 631539342,
396695565, 38780154, 695798271, 469819224, 439587099, 69045921, 682966116,
112310856, 64943298, 534475872, 40215357, 389728458, 286368453, 736006257,
501181650, 54829908, 603489402, 338032656, 512182818, 627500097, 462674016,
3103092, 157324491, 43978329, 596818971, 259025598, 9088632, 91991781,
577291428, 211245489, 429471231, 142626330, 172560633, 510907446, 444609585,
758102058, 375112647, 744786693, 276174402, 19259856, 233672418, 745389414,
225772848, 23385663, 324290610, 519804558, 120337812, 402578568, 360676008,
450089262, 551043738, 337388940, 512108856, 28879011, 690040638, 106017282,
558262341, 99972432, 608226003, 612152037, 42414435, 776201013, 39580443,
518796945, 494437752, 583194366, 723936555, 415359657, 309569589, 751104774,
166684527, 249229170, 353120823, 130668327, 753823584, 580966092, 561963717,
543672234, 393846327, 586278000, 327398400, 278403867, 156455586, 363920382,
190245195, 290039148, 547014447, 466218648, 146037150, 585462906, 666008595,
691786683, 374707494, 622498779, 231158277, 685740951, 115612245, 681825249,
545555745, 551718468, 277206615, 640171035, 757727334, 195193908, 658656684,
457760646, 225925875, 505761984, 18685233, 506832921, 112511021, 396846646,
290147622, 113924623, 669986155, 336008070, 63611061, 238586775, 119956662,
616557739, 772784623, 334527774, 410403148, 51933421};
int a2[] = {
0, 482164403, 768209115, 462063756, 154906374, 36099042, 341766705,
678182556, 621882744, 478771358, 231881111, 175889805, 243630450, 168908523,
671961765, 55761813, 652682670, 773939082, 517628076, 756201264, 124604900,
750976272, 498253248, 676047609, 137170026, 705610017, 495032139, 561797418,
703097347, 500815609, 95984586, 739707108, 265613565, 387099846, 777331779,
594676173, 591219559, 407997044, 208947235, 93337440, 478908360, 685013007,
487033953, 671903001, 39521181, 738490312, 33785059, 465470131, 310453920,
54648783, 346831137, 427694175, 474743430, 705296781, 435828036, 429824745,
663532359, 261388683, 244690731, 533997135, 596108961, 506813013, 371892402,
590145264, 104733162, 143420103, 654339672, 700348950, 685038942, 578826927,
286484229, 501639192, 434962491, 299270097, 27702486, 335375775, 111746817,
565603164, 294926121, 676063665, 735862995, 710035809, 437011960, 668528077,
138765186, 508213986, 615036450, 353784942, 624827616, 343900011, 241289776,
52410890, 72018835, 352406796, 415705878, 4802637, 376367145, 65589678,
333633477, 341834527, 303717460, 282387700, 42951006, 254706039, 423048528,
526429710, 68131467, 669954708, 12787348, 500636381, 317959019, 479433192,
657133515, 416259390, 610216692, 340129188, 44594256, 257373347, 138718678,
530767740, 292922628, 37220268, 605295159, 480722613, 458170419, 30540300,
487159055, 232966794, 149150650};
int C[260][260], f[260][260][260];
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (n == 256) return printf("%d\n", a1[m]), 0;
if (n == 128) return printf("%d\n", a2[m]), 0;
for (int i = 0; i <= n; i++)
for (int j = C[i][0] = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % p;
f[0][0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int k = 0; k <= j; k++)
if (f[i - 1][j][k])
for (int l = 0; j + l <= n; l++)
f[i][j + l][k + (l != i) * l] =
(f[i][j + l][k + (l != i) * l] +
(long long)f[i - 1][j][k] * C[n - j][l]) %
p;
printf("%d\n", f[n][n][m]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[200005], nxt[200005], ans;
bool check(long long sum, long long pro, long long len) {
long long temp = pro - sum * k;
if (temp % k) return false;
if (temp / k >= 0 && temp / k <= len)
return true;
else
return false;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n, pos = n + 1; i >= 1; i--) {
nxt[i] = pos;
if (a[i] > 1) pos = i;
}
for (int i = 1; i <= n; i++) {
long long pro = 1, sum = 0;
for (int j = i; j <= n; j = nxt[j]) {
if (pro >= 1e18 / a[j]) break;
pro *= a[j];
sum += a[j];
if (check(sum, pro, nxt[j] - j - 1)) ans++;
sum += nxt[j] - j - 1;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200007;
int n, a[MAXN], p[MAXN];
set<int> done;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
p[a[i]] = i;
}
done.insert(0);
done.insert(n + 1);
int ans = 0;
for (int x = n; x >= 3; --x) {
int m = p[x], l, r;
auto it = done.upper_bound(m);
r = (*it);
--it;
l = (*it);
if (m - l < r - m) {
for (int i = l + 1; i <= m - 1; ++i) {
int j = p[x - a[i]];
if (m < j && j < r) ++ans;
}
} else {
for (int i = m + 1; i <= r - 1; ++i) {
int j = p[x - a[i]];
if (l < j && j < m) ++ans;
}
}
done.insert(m);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll OO = 1e8;
int di[8] = {0, 0, 1, -1, -1, 1, -1, 1};
int dj[8] = {1, -1, 0, 0, 1, 1, -1, -1};
string ys = "YES", no = "NO";
const long double dgr = acos(-1) / 180, dg = 180 / acos(-1);
const int mod = 1e18, N = 2e5, M = 50000;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
int a, b, c;
double ans = 0;
vector<int> v(n);
for (auto& i : v) cin >> i;
while (m--) {
cin >> a >> b >> c;
ans = max(ans, (double)(v[a - 1] + v[b - 1]) / c);
}
cout << fixed << setprecision(15) << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int inf = 0x3f3f3f3f;
const int MAXN = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
void file() {}
const int N = 3e5 + 5;
int fat[N * 2], Size[N * 2], n, k;
vector<int> vec[N];
int find(int x) { return fat[x] == x ? x : fat[x] = find(fat[x]); }
int calc(int x) {
int y = (x <= k ? x + k : x - k);
x = find(x);
y = find(y);
if (x == 0 || y == 0) return Size[x + y];
return min(Size[x], Size[y]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (y == 0) swap(x, y);
fat[y] = x;
if (x != 0) Size[x] += Size[y];
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
string str;
cin >> n >> k >> str;
for (int i = 1; i <= k; i++) fat[i] = i, fat[i + k] = i + k, Size[i] = 1;
for (int i = 1; i <= k; i++) {
int tn;
cin >> tn;
for (int j = 0; j < tn; j++) {
int pos;
cin >> pos;
vec[pos].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
ans -= calc(x);
if (str[i - 1] == '1')
fat[find(x)] = 0;
else
fat[find(x + k)] = 0;
ans += calc(x);
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
if (str[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= calc(x);
ans -= calc(y);
merge(x, y);
merge(x + k, y + k);
ans += calc(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= calc(x);
ans -= calc(y);
merge(x, y + k);
merge(x + k, y);
ans += calc(x);
}
}
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 7;
const long long mod = 1e9 + 7;
inline long long read() {
long long x = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || '9' < ch) f |= ch == '-', ch = getchar();
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
void out(long long x) {
int stackk[20];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int top = 0;
while (x) stackk[++top] = x % 10, x /= 10;
while (top) putchar(stackk[top--] + '0');
}
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int n, m;
struct Node {
int h, l, t;
} a[maxn];
bool cmp(Node x, Node y) {
if (x.t != y.t)
return x.t < y.t;
else if (x.h != y.h)
return x.l < y.l;
else
return x.h > y.h;
}
int main() {
ios::sync_with_stdio(false);
int QAQ;
cin >> QAQ;
while (QAQ--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i].t >> a[i].l >> a[i].h;
sort(a + 1, a + 1 + n, cmp);
int flag = 1;
a[0].t = 0;
int last_time = 0, high = m, le = m;
for (int i = 1; i <= n; i++) {
int cha = a[i].t - a[i - 1].t;
high += cha;
le -= cha;
if (high < a[i].l) {
flag = 0;
break;
}
if (le > a[i].h) {
flag = 0;
break;
}
le = max(a[i].l, le);
high = min(a[i].h, high);
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const int N = 100100;
const double PI = 3.141592654;
const double eps = 0.00000001;
double sqr(double x) { return x * x; }
struct Point {
double x, y;
Point() {}
Point(double x, double y) : x(x), y(y) {}
Point rotate(double alpha) {
return Point(cos(alpha) * x - sin(alpha) * y,
sin(alpha) * x + cos(alpha) * y);
}
double kc() { return sqrt(x * x + y * y); }
double operator*(Point A) {
double s, ss;
s = A.x * x + A.y * y;
ss = A.kc() * kc();
return acos(s / ss);
}
void print() { cout << x << " " << y << endl; }
} g, b, m;
double dis(Point A, Point B) { return sqrt(sqr(A.x - B.x) + sqr(A.y - B.y)); }
struct line {
double a, b, c;
line() {}
line(double a, double b, double c) : a(a), b(b), c(c) {}
} d, d1;
double vg, vb, r, R, res;
bool inside(Point A, Point B, Point C) {
double dst1 = dis(A, B);
double dst2 = dis(B, C);
double dst3 = dis(A, C);
return (abs(dst1 + dst2 - dst3) <= eps);
}
Point giao(line A, line B) {
A.c = -A.c;
B.c = -B.c;
double d = A.a * B.b - A.b * B.a;
double dx = A.c * B.b - A.b * B.c;
double dy = A.a * B.c - A.c * B.a;
return Point(dx / d, dy / d);
}
bool OK(double ttime) {
double goc = ttime * vg / R;
Point g2 = g.rotate(goc);
double x = b.y - g2.y;
double y = g2.x - b.x;
double z = x * b.x + y * b.y;
d = line(x, y, -z);
d1 = line(y, -x, 0);
m = giao(d, d1);
bool flag = true;
if (m.kc() >= r)
flag = false;
else
flag = inside(g2, m, b);
double ans;
if (flag) {
double total = b * g2;
double t1 = acos(r / g2.kc());
double t2 = acos(r / b.kc());
total -= (t1 + t2);
ans = r * total;
ans += sqrt(sqr(g2.kc()) - sqr(r));
ans += sqrt(sqr(b.kc()) - sqr(r));
if (ans <= ttime * vb) return true;
} else {
ans = dis(g2, b);
if (ans <= ttime * vb) return true;
}
return false;
}
int main() {
double x, y;
cin >> x >> y >> vg;
g = Point(x, y);
R = sqrt(sqr(x) + sqr(y));
cin >> x >> y >> vb >> r;
b = Point(x, y);
double low, high, mid;
low = 0;
high = INF;
for (int i = 1; i <= 100; i++) {
mid = (low + high) / 2;
if (OK(mid))
res = mid, high = mid;
else
low = mid;
}
printf("%.17lf", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int q;
int n = 1;
int par[500007];
int d = 60;
double dp[500007][63];
int p1, p2;
vector<int> sta;
void ans(int v) {
double res = 0.0;
for (int i = 1; i <= d; i++) {
res += 1.0 - dp[v][i];
}
printf("%.10lf\n", res);
}
void add(int v) {
n++;
par[n] = v;
sta.clear();
v = n;
for (int i = 1; i <= d; i++) {
dp[n][i] = 1.0;
}
for (int i = 1; i <= d + 1 && v; i++) {
sta.push_back(v);
v = par[v];
}
for (int i = (int)sta.size() - 2; i > 0; i--) {
dp[sta[i + 1]][i + 1] /= (dp[sta[i]][i] + 1.0) / 2.0;
}
for (int i = 0; i + 1 < (int)sta.size(); i++) {
dp[sta[i + 1]][i + 1] *= (dp[sta[i]][i] + 1.0) / 2.0;
}
}
int main() {
scanf("%d", &q);
for (int i = 1; i <= d; i++) {
dp[1][i] = 1.0;
}
while (q--) {
scanf("%d%d", &p1, &p2);
if (p1 == 1)
add(p2);
else
ans(p2);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define FOR(i, n, m) for(ll i = n; i < (int)m; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define pb push_back
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
constexpr ll inf = 1000000000;
constexpr ll mod = 998244353;
constexpr long double eps = 1e-15;
template <typename T>
struct segment_tree {
private:
int n;
const function<T(T, T)> op;
const T ie;
vector<T> seq;
public:
segment_tree(int _n, function<T(T, T)> op, const T ie) : op(op), ie(ie) {
n = 1;
while(n < _n) n *= 2;
seq.resize(2 * n - 1);
for(int i = 0; i < 2 * n - 1; i++) seq[i] = ie;
}
void update(int k, const T e) {
k += n - 1;
seq[k] = e;
while(k > 0) {
k = (k - 1) / 2;
seq[k] = op(seq[k * 2 + 1], seq[k * 2 + 2]);
}
}
T get(int k) {
k += n - 1;
return seq[k];
}
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if(r == -1) r = n;
if(r <= a || b <= l) return ie;
if(a <= l && r <= b) return seq[k];
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return op(vl, vr);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = (int)s.size();
segment_tree<int> rmq(n, [](int a, int b){return min(a, b);}, inf);
int sum = 0;
ll ans = 0;
vector<char> ss;
stack<P> st;
vector<vector<int>> v(2 * n + 1);
v[n].pb(0);
rmq.update(0, 0);
REP(i, n) {
ll diff = 0;
if(s[i] == '(' || s[i] == ')') {
if(s[i] == '(') sum++;
else sum--;
ss.push_back(s[i]);
int x = (int)st.size() + 1;
rmq.update(x, sum);
int l = -1, r = x;
while(r - l > 1) {
int m = (l + r) / 2;
if(rmq.query(m, x) < sum) l = m;
else r = m;
}
v[sum + n].push_back(x + 1);
int tt = r;
l = -1; r = (int)v[sum + n].size() - 1;
while(r - l > 1) {
int m = (l + r) / 2;
if(v[sum + n][m] >= tt) r = m;
else l = m;
}
diff = (int)v[sum + n].size() - 1 - r;
ans += diff;
st.push({sum, diff});
} else {
auto tmp = st.top();
v[tmp.first + n].pop_back();
ans -= tmp.second;
st.pop();
if(ss.back() == '(') sum--;
else sum++;
ss.pop_back();
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
int sz1 , sz2;
string s;
vector<int> c[128];
int off[128][322];
int dp[301][301];
pair<int,int> to[301][301];
int flag[301][301];
int dp_search(int sz1,int sz2){
memset(dp,-1,sizeof(dp));
memset(flag,0,sizeof(flag));
int r;
dp[0][sz1] = 0;
to[0][sz1] = make_pair(-1,-1);
for(int p1 = 0 ; p1 <= sz1 ; p1++){
for(int p2 = sz1 ; p2 <= sz2 ; p2++){
if(dp[p1][p2] != -1){
if(p1 < sz1){
int i = off[s[p1]][p2];
if(i != 9999){
r = dp[p1][p2]+1;
if(r>dp[p1+1][i+1]){
to[p1+1][i+1] = make_pair(p1,p2);
dp[p1+1][i+1] = r;
flag[p1+1][i+1] = 1;
}
}
r = dp[p1][p2];
if(r > dp[p1+1][p2]){
to[p1+1][p2] = make_pair(p1,p2);
dp[p1+1][p2] = r;
}
}
if(p2 < sz2){
r = dp[p1][p2];
if(r > dp[p1][p2+1]){
to[p1][p2+1] = make_pair(p1,p2);
dp[p1][p2+1] = r;
}
}
}
}
}
return dp[sz1][sz2];
}
string get(int sz1,int sz2){
string ans = "";
while(sz1 != -1){
int x = to[sz1][sz2].first;
int y = to[sz1][sz2].second;
if( flag[sz1][sz2] ){
ans = string(1,s[x]) + ans;
}
sz1 = x;
sz2 = y;
}
return ans;
}
int main(){
while(cin >> s && s[0] != '#'){
int last[26];
for(int i = 0 ; i < 26 ; i++) last[i] = 9999;
for(int i = s.size() ; i >= 0 ; i--){
last[s[i]-'A'] = i;
for(int j = 0 ; j < 26 ; j++){
off[j+'A'][i] = last[j];
}
}
int save[333]={0};
// Ü ^ñ©çâéÆÍâÈÁ½æË
int currentmx = 0;
for(int i = s.size()/2 ; i >= 1 ; i--){
sz1 = i; sz2 = s.size();
if(min(sz1,sz2-sz1) <= currentmx ) continue;
save[i] = dp_search(sz1,sz2);
currentmx = max(save[i],currentmx);
}
for(int i = s.size()/2+1 ; i < s.size() ; i++){
sz1 = i; sz2 = s.size();
if(min(sz1,sz2-sz1) <= currentmx ) continue;
save[i] = dp_search(sz1,sz2);
currentmx = max(save[i],currentmx);
}
for(int i = 1 ; i < s.size() ; i++){
if(save[i] == currentmx){
sz1 = i; sz2 = s.size();
dp_search(sz1,sz2);
cout << get(sz1,sz2) << endl;
break;
}
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int t, a, b, c;
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> a >> b >> c;
int x = min(b, c / 2);
b -= x;
int y = min(a, b / 2);
cout << 3 * (x + y) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const int oo = 1 << 30;
long long tmax[4 * maxn], tsum[4 * maxn], A[maxn], N, Q;
int sig;
void build(int node, int start, int end) {
if (start == end) {
tmax[node] = A[start];
tsum[node] = A[start];
return;
}
int mid = (start + end) >> 1;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tsum[node] = tsum[2 * node] + tsum[2 * node + 1];
tmax[node] = max(tmax[2 * node], tmax[2 * node + 1]);
}
void update(int node, int start, int end, int idx, long long val) {
if (start > idx || end < idx) return;
if (start == idx && end == idx) {
tsum[node] = val;
tmax[node] = val;
return;
}
int mid = (start + end) >> 1;
update(2 * node, start, mid, idx, val);
update(2 * node + 1, mid + 1, end, idx, val);
tsum[node] = tsum[2 * node] + tsum[2 * node + 1];
tmax[node] = max(tmax[2 * node], tmax[2 * node + 1]);
}
void find(int node, int start, int end, int l, int r, long long val) {
if (sig != -1) return;
if (start > r || end < l) return;
if (tmax[node] < val) return;
if (start == end && val <= tmax[node]) {
sig = start;
return;
}
int mid = (start + end) >> 1;
find(2 * node, start, mid, l, r, val);
find(2 * node + 1, mid + 1, end, l, r, val);
}
long long query(int node, int start, int end, int l, int r) {
if (start > r || end < l) return 0;
if (start >= l && end <= r) return tsum[node];
int mid = (start + end) >> 1;
long long p1 = query(2 * node, start, mid, l, r);
long long p2 = query(2 * node + 1, mid + 1, end, l, r);
return p1 + p2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> Q;
for (int i = 1; i < N + 1; i++) cin >> A[i];
build(1, 0, N);
while (Q--) {
long long idx, x, ac, val, ant, res = -1;
cin >> idx >> x;
update(1, 0, N, idx, x);
ant = 0;
sig = 1;
while (1) {
if (sig == -1) break;
ac = query(1, 0, N, 0, sig - 1);
val = query(1, 0, N, sig, sig);
if (ac == val) {
res = sig;
break;
}
ant = sig + 1;
sig = -1;
find(1, 0, N, ant, N, ac + val);
}
cout << res << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> sticks(6);
for (int i = 0; i < 6; i++) cin >> sticks[i];
string ans = "Alien";
sort(sticks.begin(), sticks.end());
do {
set<int> vals;
for (int i = 0; i < 4; i++) vals.insert(sticks[i]);
if (vals.size() == 1) {
ans = "Bear";
if (sticks[4] == sticks[5]) {
ans = "Elephant";
break;
}
}
} while (next_permutation(sticks.begin(), sticks.end()));
cout << ans << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long cur = 0, pre = 0;
long long ans = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'R') {
pre = i + 1;
}
cur = i + 1;
ans = max(ans, cur - pre);
}
long long x = s.length() + 1;
if (x - pre > ans)
cout << x - pre << endl;
else
cout << ans + 1 << endl;
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+10;
int n,v[20],x[N],dep,dpl[N],dpr[N];
int blo[20][N],L[20][N],R[20][N];
void init(int dep){
int cnt=0;
blo[dep][1]=L[dep][1]=R[dep][1]=cnt=1;
for (int i=2;i<=n;i++){
if (x[i-1]+v[dep]>=x[i]) blo[dep][i]=cnt,R[dep][cnt]++;else
blo[dep][i]=++cnt,L[dep][cnt]=R[dep][cnt]=i;
}
L[dep][0]=1;R[dep][0]=n;
}
bool ans[N];
int main()
{
scanf("%d%d",&n,&v[0]);
while (v[dep]) v[dep+1]=v[dep]>>1,dep++;
for (int i=1;i<=n;i++) scanf("%d",&x[i]);
for (int i=0;i<=dep;i++) init(i);
int U=(1<<dep)-1;
for (int S=1;S<=U;S++)
for (int i=0;i<dep;i++)
if (S>>i&1) dpl[S]=max(dpl[S],R[i+1][blo[i+1][dpl[S^(1<<i)]+1]]);
for (int S=0;S<=U;S++) dpr[S]=n+1;
for (int S=1;S<=U;S++)
for (int i=0;i<dep;i++)
if (S>>i&1) dpr[S]=min(dpr[S],L[i+1][blo[i+1][dpr[S^(1<<i)]-1]]);
if (blo[0][n]<=20){
for (int i=1;i<=blo[0][n];i++){
int l=L[0][i],r=R[0][i];bool ok=0;
for (int S=0;S<=U;S++)
if (dpl[S]>=l-1&&dpr[U^S]<=r+1) ok=1;
if (!ok) continue;
for (int j=l;j<=r;j++) ans[j]=1;
}
}
for (int i=1;i<=n;i++) puts(ans[i]?"Possible":"Impossible");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 85;
int N, n, sep[maxn << 1], L[maxn], R[maxn], minL[maxn][maxn], maxR[maxn][maxn];
double ans[maxn][maxn], f[maxn][maxn][maxn], reci[maxn];
void Push(int x, int i, int z) {
double a, b, c;
a = double(min(sep[x], R[z]) - L[z]) * reci[z];
b = double(sep[x + 1] - sep[x]) * reci[z];
c = double(R[z] - max(L[z], sep[x + 1])) * reci[z];
memset(f[i + 1], 0, sizeof f[i + 1]);
for (int j = 0; j <= i; j++)
for (int k = 0; k <= i - j; k++) {
if (L[z] < sep[x]) f[i + 1][j + 1][k] += f[i][j][k] * a;
if (L[z] <= sep[x] && R[z] > sep[x]) f[i + 1][j][k + 1] += f[i][j][k] * b;
if (R[z] > sep[x + 1]) f[i + 1][j][k] += f[i][j][k] * c;
}
}
void Calc(int x, int l, int r) {
if (l == r) {
if (L[l] <= sep[x] && R[l] > sep[x]) {
double p = double(sep[x + 1] - sep[x]) * reci[l];
for (int i = 0; i <= N - 1; i++)
for (int j = 0; j <= N - 1 - i; j++) {
ans[l][i + 1] += f[N - 1][i][j] * p / (j + 1);
ans[l][i + j + 2] -= f[N - 1][i][j] * p / (j + 1);
}
}
return;
}
int mid((l + r) >> 1);
if (minL[l][mid] <= sep[x] && maxR[l][mid] > sep[x]) {
for (int i = N - (r - l + 1), z = mid + 1; z <= r; i++, z++) Push(x, i, z);
Calc(x, l, mid);
}
if (minL[mid + 1][r] <= sep[x] && maxR[mid + 1][r] > sep[x]) {
for (int i = N - (r - l + 1), z = l; z <= mid; i++, z++) Push(x, i, z);
Calc(x, mid + 1, r);
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d%d", &L[i], &R[i]);
sep[n++] = L[i], sep[n++] = R[i];
reci[i] = 1.0 / (R[i] - L[i]);
}
for (int i = 1; i <= N; i++) {
minL[i][i - 1] = 0;
maxR[i][i - 1] = 0x7fffffff;
for (int j = i; j <= N; j++) {
minL[i][j] = min(minL[i][j - 1], L[j]);
maxR[i][j] = max(maxR[i][j - 1], R[j]);
}
}
sort(sep, sep + n);
n = unique(sep, sep + n) - sep;
f[0][0][0] = 1;
for (int i = 0; i < n - 1; i++) Calc(i, 1, N);
for (int i = 1; i <= N; i++) {
double p(0);
for (int j = 1; j <= N; j++) {
printf("%.8f", p += ans[i][j]);
putchar(j < N ? ' ' : '\n');
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1.0);
const int MOD = (int)1e9 + 7;
set<string> hashh;
int main() {
int n, m;
char dat[25][25];
scanf("%d %d", &n, &m);
for (int i = 0; i <= n - 1; i += 1) scanf("%s", dat[i]);
pair<int, int> poss = make_pair(n, m);
int res = 0;
for (int x = 1; x <= n; x += 1)
for (int y = 1; y <= m; y += 1) {
if (n % x || m % y) continue;
bool isFound = false;
hashh.clear();
for (int a = 0; a <= n / x - 1; a += 1)
for (int b = 0; b <= m / y - 1; b += 1) {
string a1 = "", a2 = "", a3 = "", a4 = "";
for (int i = 0; i <= x - 1; i += 1) {
for (int j = 0; j <= y - 1; j += 1)
a1.push_back(dat[a * x + i][b * y + j]);
a1.push_back(' ');
}
if (hashh.find(a1) != hashh.end()) isFound = true;
hashh.insert(a1);
for (int j = y - 1; j >= 0; j -= 1) {
for (int i = 0; i <= x - 1; i += 1)
a2.push_back(dat[a * x + i][b * y + j]);
a2.push_back(' ');
}
if (a2 != a1)
if (hashh.find(a2) != hashh.end()) isFound = true;
hashh.insert(a2);
for (int i = x - 1; i >= 0; i -= 1) {
for (int j = y - 1; j >= 0; j -= 1)
a3.push_back(dat[a * x + i][b * y + j]);
a3.push_back(' ');
}
if (a3 != a1 && a3 != a2)
if (hashh.find(a3) != hashh.end()) isFound = true;
hashh.insert(a3);
for (int j = 0; j <= y - 1; j += 1) {
for (int i = x - 1; i >= 0; i -= 1)
a4.push_back(dat[a * x + i][b * y + j]);
a4.push_back(' ');
}
if (a4 != a1 && a4 != a2 && a4 != a3)
if (hashh.find(a4) != hashh.end()) isFound = true;
hashh.insert(a4);
}
if (!isFound) {
res++;
if (poss.first * poss.second == x * y && poss.first > x)
poss = make_pair(x, y);
if (poss.first * poss.second > x * y) poss = make_pair(x, y);
}
}
printf("%d\n%d %d\n", res, poss.first, poss.second);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod0 = 1e9 + 7;
const long long mod1 = 998244353;
const long long mod2 = 1e9 + 9;
const long long mod3 = 2147483647;
const int maxn = 2e5 + 3;
const int inf = 2 * 1024 * 1024 * 1023;
const long double eps = 1e-7;
int n, k;
void init() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(16);
}
int main() {
init();
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end());
cout << min(a.back() - a[1], a[n - 2] - a[0]) << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,a;
cin>>n>>a;
if(n%500<=a){
cout<<"Yes";
}
else
cout<<"No";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int id = n - 1;
while (id >= 0 && a[id] <= a[id - 1]) id--;
while (id >= 0 && a[id] >= a[id - 1]) id--;
if (id < 0) id = 0;
cout << id << endl;
}
return 0;
}
| 3 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
string str;
while(getline(cin,str),str!="END OF INPUT"){
str+=" ";
int cnt=0;
for(int i=0;i<str.length();i++){
if(str[i]==' '){
cout<<cnt;
cnt=0;
}
else{
cnt++;
}
}
cout<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2010];
int ans;
void dfs(int u, int dep) {
if (g[u].size() == 0) ans = max(ans, dep);
for (int i = 0; i < (int)g[u].size(); i++) {
dfs(g[u][i], dep + 1);
}
}
int main() {
int N, u;
scanf("%d", &N);
ans = 0;
for (int v = 1; v <= N; v++) {
scanf("%d", &u);
if (u == -1)
g[0].push_back(v);
else
g[u].push_back(v);
}
dfs(0, 0);
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
std::cin >> n;
int a = 0, d = 0;
std::string s;
std::cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a++;
else
d++;
}
if (a > d)
std::cout << "Anton";
else if (d > a)
std::cout << "Danik";
else
std::cout << "Friendship";
}
| 1 |
#include <stdio.h>
int main()
{
int n;int j=0;
scanf("%d",&n);
char s[n+1];
scanf("%s",s);
for(int i=0;s[i]!='\0';i++)
{
if(s[i]=='A'&&s[i+1]=='B'&&s[i+2]=='C')
j++;
}
printf("%d",j);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
a[0] = 0;
sort(a, a + (n + 1));
int ans;
int sum = 0;
int index = -1;
for (int i = 1; i <= n; i++) {
int change = a[i] - a[i - 1] - 1;
if (change <= 0) {
ans = a[i];
} else if (change > 0) {
if (change == k) {
ans = a[i];
index = i;
k = 0;
break;
} else if (change > k) {
ans = a[i - 1] + k;
k = 0;
break;
} else {
k = k - change;
ans = a[i];
}
}
}
if (index != -1) {
int i;
for (i = index; i <= n - 1; i++) {
if (a[i + 1] - a[i] > 1) {
break;
}
}
ans = a[i];
}
if (k != 0) {
ans = ans + k;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto i : v) os << "(" << i.x << ", " << i.y << ") ";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (auto i : v) os << i << " ";
return os;
}
template <typename T>
T read() {
T sgn = 1, res = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') sgn = -sgn;
c = getchar();
}
while ('0' <= c && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
return res * sgn;
}
struct node {
int x, y, id;
node(int x = 0, int y = 0, int id = 0) : x(x), y(y), id(id) {}
bool operator<(const node& cmp) const {
if (x != cmp.x)
return x < cmp.x;
else
return id < cmp.id;
}
};
const int INF = 1e9 + 7;
const int N = 1e5 + 233;
int dig[N], cur[N];
vector<node> s;
set<int> cnt;
int round_div(int x, int y) {
double a = static_cast<double>(x);
double b = static_cast<double>(y);
return static_cast<int>(a / b * 100 + .5);
}
int main() {
int n = read<int>();
int k = read<int>();
int com = 0;
int c = 0;
for (int i = 0; i < n; ++i) dig[i] = read<int>();
while (s.size() < k) {
s.emplace_back(dig[c], dig[c], c);
c++;
}
sort(s.begin(), s.end());
int ans = 0;
while (com < n) {
int i = 0;
while (i < s.size() && s[i].x == 0) {
if (c < n) {
s[i++] = node(dig[c], dig[c], c);
c++;
} else
s[i++] = INF;
com++;
}
for (auto& i : s) i.x--;
sort(s.begin(), s.end());
int rate = round_div(com, n);
for (auto i : s) {
if (rate && rate == i.y - i.x) {
cnt.insert(i.id);
}
}
}
printf("%d\n", cnt.size());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long x[20], n = 0, ans = 0, current;
long long cnv(char c) {
if (c == 'a') return current;
return c - '0';
}
long long f(string t) {
long long ans = 0, cur = 0;
string s = "+" + t + "+";
for (int i = 1; i < s.length(); i += 2) {
if (s[i - 1] == '+' && s[i + 1] == '+') ans += cnv(s[i]);
if (s[i - 1] == '+' && s[i + 1] == '*') {
ans += cur;
cur = cnv(s[i]);
}
if (s[i - 1] == '*' && s[i + 1] == '*') cur *= cnv(s[i]);
if (s[i - 1] == '*' && s[i + 1] == '+') cur *= cnv(s[i]);
}
return ans + cur;
}
string sub(int l, int r, string u) { return u.substr(l, r - l + 1); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
s = "1*" + s + "*1";
for (int i = 1; i < s.length(); i += 2) {
if (s[i] == '*') {
x[n] = i;
n++;
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string t1 = sub(0, x[i] - 1, s);
string t2 = sub(x[i] + 1, x[j] - 1, s);
string t3 = sub(x[j] + 1, s.length() - 1, s);
current = f(t2);
long long now = f(t1 + "*a*" + t3);
if (now > ans) ans = now;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 85;
int n, m;
int a[N];
vector<int> vec[N];
pair<pair<int, int>, int> b[N];
int mapp[N];
int ans[N];
int seg[N << 2];
inline void add(int, int, int = 1, int = 0, int = N);
inline int get(int, int = 1, int = 0, int = N);
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
mapp[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int j = 1;
while (j * i <= n) {
if (mapp[j * i] >= mapp[i]) vec[mapp[j * i]].push_back(mapp[i]);
if (mapp[i] > mapp[j * i]) vec[mapp[i]].push_back(mapp[j * i]);
j++;
}
}
for (int i = 0; i < m; i++) {
cin >> b[i].first.second >> b[i].first.first;
b[i].first.second--;
b[i].first.first--;
b[i].second = i;
}
sort(b, b + m);
int k = 0;
for (int t = 0; t < m; t++) {
while (k <= b[t].first.first) {
for (int i = 0; i < vec[k].size(); i++) add(0, vec[k][i] + 1);
k++;
}
ans[b[t].second] = get(b[t].first.second);
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
inline void add(int st, int en, int id, int l, int r) {
if (en <= l or r <= st) return;
if (st <= l and r <= en) {
seg[id]++;
return;
}
int mid = (l + r) >> 1, lc = id << 1, rc = lc | 1;
add(st, en, lc, l, mid);
add(st, en, rc, mid, r);
}
inline int get(int idx, int id, int l, int r) {
if (idx < l or r <= idx) return 0;
if (l + 1 == r) return seg[id];
int mid = (l + r) >> 1, lc = id << 1, rc = lc | 1;
return get(idx, lc, l, mid) + get(idx, rc, mid, r) + seg[id];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream second(s);
string x;
while (getline(second, x, c)) v.emplace_back(x);
return move(v);
}
template <typename T, typename... Args>
inline string arrStr(T arr, int n) {
stringstream s;
s << "[";
for (int i = 0; i < n - 1; i++) s << arr[i] << ",";
s << arr[n - 1] << "]";
return s.str();
}
inline void __evars_begin(int line) { cerr << "#" << line << ": "; }
template <typename T>
inline void __evars_out_var(vector<T> val) {
cerr << arrStr(val, val.size());
}
template <typename T>
inline void __evars_out_var(T* val) {
cerr << arrStr(val, 10);
}
template <typename T>
inline void __evars_out_var(T val) {
cerr << val;
}
inline void __evars(vector<string>::iterator it) { cerr << '\n'; }
template <typename T, typename... Args>
inline void __evars(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << "=";
__evars_out_var(a);
cerr << "; ";
__evars(++it, args...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int dx[8] = {1, -1, 0, 0, -1, -1, 1, 1};
int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
const long long inf = 1000000007;
vector<int> vis(500010, 0), dis(500010, 0), dis1(500010, -1), par(500010, 0),
col(500010, 0);
vector<pair<int, int>> adj[500010];
int myrandom(int i) { return std::rand() % i; }
const int MAX = 50010;
using namespace std;
void binary(int num) {
vector<int> v;
while (num) {
v.push_back(num % 2);
num = num / 2;
}
reverse((v).begin(), (v).end());
for (auto i : v) {
cout << i;
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int len = 1 << n;
int dp[m + 1][len][26];
memset(dp, 0, sizeof(dp));
vector<string> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int mask[m][26];
for (int i = 0; i < m; i++) {
for (int j = 0; j < 26; j++) {
int cur = 0;
for (int k = 0; k < n; k++) {
if (v[k][i] != j + 'a') {
cur = cur | (1 << k);
}
}
mask[i][j] = cur;
}
}
for (int i = 0; i < 26; i++) {
dp[0][mask[0][i]][i] = 1;
}
for (int i = 0; i < m - 1; i++) {
for (int j = 0; j < len; j++) {
for (int k = 0; k < 26; k++) {
if (dp[i][j][k]) {
for (int l = 0; l < 26; l++) {
if ((j & mask[i + 1][l]) == 0) {
dp[i + 1][j | mask[i + 1][l]][l] = dp[i][j][k];
}
}
}
}
}
}
int id = -1, ch = -1;
bool ok = false;
for (int i = 0; i < len; i++) {
for (int j = 0; j < 26; j++) {
if (dp[m - 1][i][j]) {
ok = true;
id = i;
ch = j;
}
}
}
if (!ok) {
cout << -1 << '\n';
} else {
string ans;
ans.push_back('a' + ch);
for (int i = m - 2; i >= 0; i--) {
bool flag = false;
for (int j = 0; j < len && flag == false; j++) {
for (int k = 0; k < 26; k++) {
if (dp[i][j][k] == 1) {
if ((j & mask[i + 1][ch]) == 0 && (j | mask[i + 1][ch]) == id) {
ans.push_back('a' + k);
id = j;
ch = k;
flag = true;
break;
}
}
}
if (flag) {
break;
}
}
}
reverse(ans.begin(), ans.end());
cout << ans << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
string s[101];
int n;
string t;
vector<string> res;
int main() {
ios_base::sync_with_stdio(false);
cin >> t;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> s[i];
for (int i = 1; i <= n; ++i) {
bool bl = true;
for (int j = 0; j < t.size(); ++j) {
if (t[j] != s[i][j]) {
bl = false;
break;
}
}
if (bl) res.push_back(s[i]);
}
sort(res.begin(), res.end());
if (res.size() == 0)
cout << t;
else
cout << res[0];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
cout << s.substr(0, 4) + " " + s.substr(4) << endl;
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
#define ll long long
using namespace std;
ll a[5010];
ll b[5010];
int main()
{
ll n, m;
scanf("%lld %lld", &n, &m);
for (int i = 0; i < n; i++)
scanf("%lld", &a[i]);
for (int i = 0; i < m; i++) {
ll q, w, e;
scanf("%lld %lld %lld", &q, &w, &e);
ll ans = q - 1;
for (int y = 0; y < n; y++) {
b[y] = a[y] % e;
}
w %= e;
ll sum = 0;
ll zersum = 0;
for (int y = 0; y < n; y++) {
sum += b[y];
if (!b[y])zersum++;
}
q--;
zersum = zersum * (q / n);
sum = sum * (q / n);
for (int y = 0; y < q % n; y++) {
sum += b[y];
if (!b[y])zersum++;
}
sum += w;
ans -= zersum;
ans -= (sum / e);
printf("%lld\n", ans);
}
} | 0 |
Subsets and Splits