solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int table[32][10];
char buf[32];
int len;
long long int ans[6];
bool go(int loc, int carry) {
if (loc == len)
return !carry;
else if (table[loc][carry])
return table[loc][carry] - 1;
else {
int& v = table[loc][carry];
for (int i = 0; !v && i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
int d = carry + i * 4 + j * 7;
if (d % 10 == buf[loc] && go(loc + 1, d / 10)) {
v = 1;
break;
}
}
return v++;
}
}
void go2(int loc, int carry, long long int radix) {
if (loc < len) {
for (int i = 0; i <= 6; i++)
for (int j = 0; i + j <= 6; j++) {
int d = carry + i * 4 + j * 7;
if (d % 10 == buf[loc] && go(loc + 1, d / 10)) {
for (int a = 0; a < i; a++) ans[a] += 4 * radix;
for (int b = i; b < i + j; b++) ans[b] += 7 * radix;
go2(loc + 1, d / 10, radix * 10);
return;
}
}
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long int N;
scanf("%I64d", &N);
len = 0;
do buf[len++] = N % 10;
while (N /= 10);
memset(table, 0, sizeof(table));
memset(ans, 0, sizeof(ans));
if (!go(0, 0))
puts("-1");
else {
go2(0, 0, 1);
for (int i = 0; i < 6; i++) {
if (i) printf(" ");
printf("%I64d", ans[i]);
}
printf("\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n;
cin >> n;
map<int, int> mp;
int count = 0;
vector<char> l;
string p;
int f = 0, g = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '?' && s[i] != '*') {
l.push_back(s[i]);
count++;
}
}
if (count == n) {
for (int i = 0; i < l.size(); i++) cout << l[i];
} else if (count < n) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == '*') {
f = 1;
break;
}
}
if (f == 0) {
cout << "Impossible";
return 0;
}
int d = n - count, j = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '*' && s[i] != '?') {
p = p + s[i];
}
if (s[i] == '*' && g == 0) {
while (j < d) {
p = p + s[i - 1];
j++;
}
g = 1;
}
}
cout << p;
} else {
int r = (count - n), t = 0;
for (int i = 0; i < s.size(); i++) {
if ((s[i] == '?' || s[i] == '*')) {
mp[i]++;
mp[i - 1]++;
t++;
if (t == r) {
break;
}
}
}
for (int i = 0; i < s.size(); i++) {
if (mp[i] == 0 && s[i] != '*' && s[i] != '?') {
p = p + s[i];
}
}
if (p.size() == n)
cout << p;
else
cout << "Impossible";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100100;
vector<vector<int> > g, t;
int tree[MAX], depth[MAX];
int N, q, root, v1, v2, v, val, dist;
void dfs(int v, int d, int num, int p) {
tree[v] = num;
depth[v] = d;
t[num].push_back(0);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
d++;
dfs(g[v][i], d, num, v);
}
return;
}
void add(int p, int v, int num) {
for (int i = p; i < t[num].size(); i += (i & (-i))) t[num][i] += v;
return;
}
int query(int p, int num) {
int res = 0;
for (int i = p; i > 0; i -= (i & (-i))) res += t[num][i];
return res;
}
void construct() {
g.resize(N);
for (int i = 0; i < N - 1; i++) {
scanf("%d%d", &v1, &v2);
v1--;
v2--;
g[v1].push_back(v2);
g[v2].push_back(v1);
}
t.resize(g[0].size() + 1);
root = 0;
for (int i = 0; i < g[0].size(); i++) {
t[i].push_back(0);
dfs(g[0][i], 1, i, 0);
}
t[t.size() - 1].resize(N + 10);
return;
}
void solve() {
for (int i = 0; i < q; i++) {
int ty;
scanf("%d", &ty);
if (ty == 0) {
scanf("%d%d%d", &v, &val, &dist);
v--;
if (v == 0) {
root += val;
add(1, val, t.size() - 1);
add(dist + 1, -val, t.size() - 1);
} else {
if (dist >= depth[v]) {
int left = dist - depth[v];
root += val;
add(1, val, t.size() - 1);
add(left + 1, -val, t.size() - 1);
add(left + 1, val, tree[v]);
add(depth[v] + dist + 1, -val, tree[v]);
} else {
add(depth[v] - dist, val, tree[v]);
add(depth[v] + dist + 1, -val, tree[v]);
}
}
} else {
scanf("%d", &v);
v--;
if (v == 0)
printf("%d\n", root);
else {
int res = query(depth[v], tree[v]) + query(depth[v], t.size() - 1);
printf("%d\n", res);
}
}
}
return;
}
int main() {
scanf("%d%d", &N, &q);
construct();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T chmin(T& a, T& b) {
if (a > b) return a;
}
template <class T>
T chmax(T& a, T& b) {
if (a < b) return b;
}
const long long INF = 1e18;
const int MOD = 3;
const int N = 7000;
bool v[N];
vector<long long> adj[N];
long long n;
double dist(pair<double, double> x, pair<double, double> y) {
return (x.first - y.first) * (x.first - y.first) +
(x.second - y.second) * (x.second - y.second);
}
pair<double, double> c[5], p[5];
bool issquare() {
double a = dist(p[0], p[1]);
double b = dist(p[0], p[2]);
double c = dist(p[0], p[3]);
if (a == b && 2 * a == c) {
double d = dist(p[1], p[3]);
return (d == dist(p[2], p[3]) && d == a && p[0] != p[1] && p[0] != p[2] &&
p[0] != p[3] && p[1] != p[2] && p[1] != p[3] && p[2] != p[3]);
}
if (b == c && 2 * b == a) {
double d = dist(p[1], p[2]);
return (d == dist(p[1], p[3]) && d == b && p[0] != p[1] && p[0] != p[2] &&
p[0] != p[3] && p[1] != p[2] && p[1] != p[3] && p[2] != p[3]);
}
if (a == c && 2 * a == b) {
double d = dist(p[1], p[2]);
return (d == dist(p[2], p[3]) && d == a && p[0] != p[1] && p[0] != p[2] &&
p[0] != p[3] && p[1] != p[2] && p[1] != p[3] && p[2] != p[3]);
}
return false;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int z = 0; z < n; z++) {
for (int i = 0; i < 4; i++)
cin >> p[i].first >> p[i].second >> c[i].first >> c[i].second;
long long flag = -1, cnt1 = 0, cnt2, cnt3, cnt4, ans = INT_MAX;
for (int i = 0; i < 4; i++) {
cnt2 = 0;
for (int j = 0; j < 4; j++) {
cnt3 = 0;
for (int k = 0; k < 4; k++) {
cnt4 = 0;
for (int l = 0; l < 4; l++) {
if (issquare()) {
ans = min(ans, cnt1 + cnt2 + cnt3 + cnt4);
flag = 1;
}
long long x = p[3].first;
p[3].first = -(p[3].second - c[3].second);
p[3].second = (x - c[3].first);
p[3].first += c[3].first;
p[3].second += c[3].second;
cnt4++;
}
long long x = p[2].first;
p[2].first = -(p[2].second - c[2].second);
p[2].second = (x - c[2].first);
p[2].first += c[2].first;
p[2].second += c[2].second;
cnt3++;
}
long long x = p[1].first;
p[1].first = -(p[1].second - c[1].second);
p[1].second = (x - c[1].first);
p[1].first += c[1].first;
p[1].second += c[1].second;
cnt2++;
}
long long x = p[0].first;
p[0].first = -(p[0].second - c[0].second);
p[0].second = (x - c[0].first);
p[0].first += c[0].first;
p[0].second += c[0].second;
cnt1++;
}
if (flag == -1)
cout << -1 << "\n";
else
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m;
while (cin >> n >> m, n) {
int cnt[11] = {};
int d, p;
for (int i = 0; i < n; i++) {
cin >> d >> p;
cnt[p] += d;
}
for (int i = 10; i >= 0; i--) {
if (m < cnt[i]) {
cnt[i] -= m;
m = 0;
} else {
m -= cnt[i];
cnt[i] = 0;
}
}
int ans = 0;
for (int i = 0; i <= 10; i++) {
ans += cnt[i] * i;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d%d", &a, &b);
double ans = 1e9;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y, v;
scanf("%d%d%d", &x, &y, &v);
x -= a, y -= b;
double tmp = sqrt(x * x + y * y) / v;
if (tmp < ans) ans = tmp;
}
printf("%.10lf\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 200005;
const double PI = 4 * atan(1);
const long long MAX = 9223372036854775807;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool issquare(long long w) { return trunc(sqrt(w)) * trunc(sqrt(w)) == w; }
bool isprime(long long u) {
for (long long i = 2; i <= (int)sqrt(u); i++) {
if (u % i == 0) return 0;
}
return 1;
}
long long mod(long long to_mod, long long MOD) {
to_mod %= MOD;
while (to_mod < 0) to_mod += MOD;
return to_mod % MOD;
}
long long moduloMultiplication(long long a, long long b, long long mod) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1) res = (res + a) % mod;
a = (2 * a) % mod;
b >>= 1;
}
return res;
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long n, m, x, y, t, k, z, w, l, r, ans;
long long ax, bx, ay, by, cx, cy;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
cin >> bx >> by;
cin >> ax >> ay;
cin >> cx >> cy;
x = max(ax, cx);
y = min(ax, cx);
if (bx > y && bx < x) {
cout << "NO";
return 0;
}
x = max(ay, cy);
y = min(ay, cy);
if (by > y && by < x) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=100003,INF=1<<30;
vector<vector<int>> state(MAX,vector<int>(7,0));
vector<int> dx={-1,0,0,1},dy={0,-1,1,0};
void DFS(int u,int v,int goal,int when){
stack<pair<int,int>> ST;
ST.push(make_pair(u,v));
state[u][v]=when;
while(!ST.empty()){
int a=ST.top().first,b=ST.top().second;
ST.pop();
for(int i=0;i<4;i++){
int c=a+dx[i],d=b+dy[i];
if(c<0||c>=goal||d<0||d>=7) continue;
if(state[c][d]==0){
ST.push(make_pair(c,d));
state[c][d]=when;
}
}
}
}
int main(){
ll N;
int M,Q;cin>>N>>M>>Q;
vector<int> A(Q);
for(int i=0;i<Q;i++){
cin>>A[i];
}
if(M%7==0){
for(int i=0;i<Q;i++){
int a=A[i]/7,b=A[i]%7;
state[a][b]=-1;
}
int now=0;
for(int i=0;i<M/7;i++){
for(int j=0;j<7;j++){
if(state[i][j]==0){
now++;
DFS(i,j,M/7,now);
}
}
}
set<pair<int,int>> se;
for(int j=0;j<7;j++){
if(state[0][j]>=0&&state[M/7-1][j]>=0) se.insert(make_pair(state[0][j],state[M/7-1][j]));
}
cout<<7*N/M*now-(7*N/M-1)*se.size()<<endl;
}else{
for(int i=0;i<Q;i++){
for(int j=0;j<7;j++){
int a=(A[i]+M*j)/7,b=(A[i]+M*j)%7;
state[a][b]=-1;
}
}
int now=0;
for(int i=0;i<M;i++){
for(int j=0;j<7;j++){
if(state[i][j]==0){
now++;
DFS(i,j,M,now);
}
}
}
set<pair<int,int>> se;
for(int j=0;j<7;j++){
if(state[0][j]>=0&&state[M-1][j]>=0) se.insert(make_pair(state[0][j],state[M-1][j]));
}
cout<<N/M*now-(N/M-1)*se.size()<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3005;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void judge() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int head[maxn], ne[maxn << 1], t[maxn << 1], S[maxn], top, cycle, num, n,
belong[maxn], dis[maxn];
bool ins[maxn], ok, oncy[maxn];
double ans = 0;
inline void addedge(int x, int y) {
ne[++num] = head[x];
head[x] = num;
t[num] = y;
}
inline void findcycle(int u, int fa) {
S[++top] = u;
ins[u] = 1;
for (int i = head[u]; i != -1; i = ne[i])
if (t[i] != fa) {
if (ok) return;
if (ins[t[i]]) {
while (S[top] != t[i]) oncy[S[top--]] = 1, cycle++;
cycle++;
oncy[t[i]] = 1;
ok = 1;
return;
}
findcycle(t[i], u);
}
top--;
}
inline void dfs_find(int u, int fa, int rt, int d) {
belong[u] = rt;
dis[u] = d;
for (int i = head[u]; i != -1; i = ne[i])
if (t[i] != fa && !oncy[t[i]]) dfs_find(t[i], u, rt, d + 1);
}
int p, first;
inline void dfs_ans(int u, int fa, int d) {
if (u == belong[p]) {
if (first) return;
first += 1;
}
ans += 1.0 / (d + 1);
for (int i = head[u]; i != -1; i = ne[i])
if (t[i] != fa) {
dfs_ans(t[i], u, d + 1);
}
}
int main() {
read(n);
for (int i = (1); i <= (n); i++) head[i] = -1;
for (int i = (1); i <= (n); i++) {
int a, b;
read(a);
read(b);
a++;
b++;
addedge(a, b);
addedge(b, a);
}
findcycle(1, -1);
for (int i = (1); i <= (n); i++)
if (oncy[i]) dfs_find(i, -1, i, 0);
for (int i = (1); i <= (n); i++) p = i, first = 0, dfs_ans(i, -1, 0);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
if (belong[i] != belong[j]) ans -= 1.0 / (dis[i] + dis[j] + cycle);
printf("%.23lf\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int mod = 1e9 + 7, inf = 1e9;
int n, l, r, x, ans = 1;
set<int> s;
char op[9];
int main() {
read(n);
s.insert(l = 0);
s.insert(r = inf);
while (n--) {
scanf("%s", op);
if (op[1] == 'D') {
read(x);
s.insert(x);
} else {
read(x);
if (x < l || r < x) {
puts("0");
return 0;
}
if (x != l && x != r) ans = ans * 2 % mod;
auto it = s.find(x);
l = *prev(it), r = *next(it);
s.erase(it);
}
}
int cnt = 0;
for (auto it = s.find(l); *it < r; it++) cnt++;
ans = (long long)ans * cnt % mod;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> t;
vector<int> t1;
vector<vector<char> > map;
vector<vector<int> > ans;
int n, m;
char c;
int xm = 0, ym = 0, max = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) t1.push_back(0);
for (int i = 0; i < n; i++) {
t.clear();
for (int j = 0; j < n; j++) {
cin >> c;
t.push_back(c);
}
t.push_back('#');
ans.push_back(t1);
map.push_back(t);
}
t.clear();
for (int i = 0; i < n; i++) t.push_back('#');
map.push_back(t);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (map[i][j] == '.') {
bool hor = true, ver = true;
for (int k = 0; k < m; k++)
if (map[i][j + k] == '#') {
hor = false;
break;
}
for (int k = 0; k < m; k++)
if (map[i + k][j] == '#') {
ver = false;
break;
}
if (hor == true)
for (int k = 0; k < m; k++) ans[i][j + k]++;
if (ver == true)
for (int k = 0; k < m; k++) ans[i + k][j]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (ans[i][j] > max) {
max = ans[i][j];
xm = i;
ym = j;
}
cout << xm + 1 << " " << ym + 1;
}
| 2 |
#include <cstdio>
#include <vector>
using namespace std;
bool check(const vector<int> &v){
int d = v[1] - v[0];
for(int i = 2; i < v.size(); ++i){
if(v[i] - v[i-1] != d) return false;
}
return true;
}
int solve(int n){
vector<int> h(n + 1), v;
for(int i = 0; i <= n; ++i){
scanf("%d", &h[i]);
}
for(int i = 0; i <= n; ++i){
v.assign(h.begin(), h.begin() + i);
v.insert(v.end(), h.begin() + (i + 1), h.end());
if(check(v)) return h[i];
}
return -1;
}
int main(){
int n;
while(scanf("%d", &n), n){
printf("%d\n", solve(n));
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vp;
const int inf = 1e9;
const ll INF = 1e18;
const db eps = 1e-10;
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define ep emplace
#define mem(a) memset(a, 0, sizeof(a))
#define copy(a, b) memcpy(a, b, sizeof(b))
#define PA cout << "pass\n"
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define TM cout << db(clock()) / CLOCKS_PER_SEC << '\n'
const int maxn = 5050;
int f[maxn][maxn];
int n, mod;
void add(int &x, int y){
x += y;
if(x >= mod) x -= mod;
}
int main(){
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> mod;
int m = n - 1 >> 1;
f[0][0] = 1;
for(int i = 1; i <= m; i++){
for(int j = 0; j <= n; j++){
for(int k = 0; i * k <= j; k++){
add(f[i][j], 1ll * f[i - 1][j - i * k] * (k + 1) % mod);
}
}
}
int res = 0;
if(n & 1){
for(int i = 1; i <= n; i++){
for(int j = 0; j * (m + 1) <= n - i; j++){
add(res, f[m][n - i - j * (m + 1)]);
}
}
}
else{
for(int i = 1; i <= n; i++){
for(int j = 0; j * (m + 1) <= n - i; j++){
add(res, 1ll * f[m][n - i - j * (m + 1)] * (j + 1) % mod);
}
}
}
cout << res << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long a, b, c, mi, mx, mid, ans = 0, x;
cin >> a >> b >> c;
mi = min(a, min(b, c));
mx = max(a, max(b, c));
mid = a + b + c - mi - mx;
ans = mi;
x = mi;
mx -= mi;
mid -= mi;
mi = 0;
ans += mid / 2;
x += mid / 2;
mx -= mid / 2;
mid -= 2 * (mid / 2);
ans += min((mx + mid) / 3, mid + x);
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long brr[1000001] = {0};
const double PI = 3.141592653589793238463;
const long long int MOD = 1000000007;
list<long long> ls;
vector<long long> v, v1, v2, vv;
set<long long> s;
map<long long, long long> mp;
stack<char> st;
stack<long long> sti;
long long mxx(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long mnn(long long a, long long b) {
if (a > b)
return b;
else
return a;
}
inline long long fp(long long bs, long long pw) {
long long res = 1;
while (pw > 0) {
if (pw % 2 == 1) {
res = (res * bs) % MOD;
}
bs = (bs * bs) % MOD;
pw = pw / 2;
}
return res;
}
long long pp(long long bs, unsigned long long pw) {
long long ans = 1;
while (pw > 0) {
if (pw & 1) ans = ans * bs;
pw = pw >> 1;
bs = bs * bs;
}
return ans;
}
bool ff22(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second < b.second);
}
bool string_match_ignoring_case(string a, string b) {
transform(a.begin(), a.end(), a.begin(), ::tolower);
transform(b.begin(), b.end(), b.begin(), ::tolower);
if (a.compare(b) == 0) return true;
return false;
}
long long ctpair(long long arr[], long long n, long long sum) {
long long i = 0, j = n - 1, ct = 0;
while (i < j) {
long long t = arr[i] + arr[j];
if (t == sum) {
i++;
j--;
ct++;
} else if (t > sum)
j--;
else
i++;
}
return ct;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, n, w, k, i, j, ans = 0, sum = 0, ct = 0, ti, q, temp, t1, t2, m,
mx, x, y, gg, g1, g2, l, r, a, b, c, d, diff;
cin >> t;
while (t--) {
cin >> n >> m;
char ch[n][m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> ch[i][j];
}
}
ct = 0;
i = n - 1;
for (j = 0; j < m - 1; j++) {
if (ch[i][j] != 'R') {
ch[i][j] = 'R';
ct++;
}
}
j = m - 1;
for (i = 0; i < n - 1; i++) {
if (ch[i][j] != 'D') {
ch[i][j] = 'D';
ct++;
}
}
cout << ct << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
int n;
int judge(int x) {
for (int i = 1; i <= x; i++)
if (a[i] >= a[n - x + i]) return 0;
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
int l = 0, r = n;
sort(a + 1, a + 1 + n);
while (l + 1 < r) {
int mid = (l + r) / 2;
if (judge(mid)) {
l = mid;
} else
r = mid - 1;
}
if (judge(r)) l = r;
printf("%d\n", l);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const bool DEBUG = 0;
int to[100100][2];
int dp[100100][2];
int x[100100];
int y[100100];
int n, m;
int tmp;
int main() {
scanf("%d %d %d %d", &n, &m, &tmp, &tmp);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &y[i]);
}
if (m == 0) {
printf("%d\n", n);
return 0;
}
memset(to, -1, sizeof to);
int j = 0;
for (int i = 0; i < n; i++) {
while (j + 1 < m && abs(y[j + 1] - x[i]) < abs(y[j] - x[i])) j++;
if (j == m - 1) {
to[i][0] = m - 1;
} else if (abs(y[j + 1] - x[i]) == abs(y[j] - x[i])) {
to[i][0] = j;
to[i][1] = j + 1;
} else {
to[i][0] = j;
}
}
dp[0][0] = 0;
dp[0][1] = (to[0][1] == -1 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i][1] = 100000000;
if (to[i][1] == -1) {
if (to[i - 1][1] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
} else if (abs(y[to[i][0]] - x[i]) > abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
}
} else if (to[i - 1][0] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = dp[i - 1][0];
} else {
dp[i][0] = dp[i - 1][0] + 1;
}
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
}
} else {
if (to[i - 1][0] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = dp[i - 1][0];
} else if (abs(y[to[i][0]] - x[i]) > abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = dp[i - 1][0] + 1;
} else {
dp[i][0] = dp[i - 1][0] + 1;
}
} else if (to[i - 1][1] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
} else if (abs(y[to[i][0]] - x[i]) > abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
}
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
}
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]);
}
}
printf("%d\n", min(dp[n - 1][0], dp[n - 1][1]));
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (int)1e9 + 7;
const long long LINF = (long long)9e18 + 7;
const long long P1 = 353251;
const long long P2 = 239017;
const long long MOD = 1e9 + 7;
const long long MOD1 = 1e9 + 7;
const long long MOD2 = 1e9 + 9;
const bool is_testing = 0;
int main() {
srand('D' + 'E' + 'N' + 'I' + 'S' + 'S' + 'O' + 'N');
if (is_testing) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
} else {
}
vector<int> d;
for (int i = 0; i <= 9; i++) {
for (int j = 0; j < 4; j++) cout << i;
cout << endl;
cout.flush();
int x, y;
cin >> x >> y;
if (x + y != 0) d.push_back(i);
}
vector<int> s;
for (int i = 0; i < 4; i++) s.push_back(i);
do {
for (int i = 0; i < 4; i++) cout << d[s[i]];
cout << endl;
cout.flush();
int x, y;
cin >> x >> y;
if (x == 4) exit(0);
} while (next_permutation(s.begin(), s.end()));
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);
#define lli long long int
#define ld long double
#define pb push_back
#define pf push_front
#define mp make_pair
#define mt make_tuple
#define all(x) (x).begin(),(x).end()
#define pll pair<lli,lli>
#define ve vector<lli>
#define vep vector<pair<lli,lli> >
#define fr(i,a,n) for(lli i=a;i<(n);i++)
#define frx(i,a,n) for(lli i=a;i>(n);i--)
#define lb lower_bound
#define ub upper_bound
#define F first
#define S second
#define db(x) cout << "[ " << x << " ]" << endl
#define db2(x,y) cout<<"[ " <<x<<" "<<y<< " ]" <<endl
#define parr(arr,a,n) fr(i,a,n) cout<<arr[i]<<" "; cout<<endl
#define mem(a,x) memset(a,x,sizeof(a));
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
void solve(){
lli n;
cin>>n;
lli from=0,to=0,rtime=0,ans=0;
lli t[n+5],x[n+5];
fr(i,0,n)cin>>t[i]>>x[i];
t[n]=1e12;
fr(i,0,n){
if(rtime<=t[i]){
from=to;
to=x[i];
rtime=t[i]+abs(to-from);
if(abs(to-from)<=t[i+1]-t[i]){
ans++;
}
}
else{
lli sign=1;
if(to<from)sign=-1;
lli c1=to-(rtime-min(rtime,t[i+1]))*sign,c2=to-(rtime-t[i])*sign;
if(c1>c2)swap(c1,c2);
if(c1<=x[i] && x[i]<=c2){
ans++;
}
}
}
cout<<ans<<endl;
}
int main(){
fast;
lli t=1;
cin>>t;
while(t--){
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int isPrime(long long n) {
if (n <= 1) return 0;
for (long long i = 2; i < n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
int main(int argc, const char* argv[]) {
long long n, k;
cin >> n >> k;
while (1) {
if (n == 0 || k == 0) {
break;
} else {
if (n >= 2 * k) {
if ((n / k) % 2 == 0) {
n = n - (n / k) * k;
} else {
n = n - ((n / k) - 1) * k;
}
} else {
if (k >= 2 * n) {
if ((k / n) % 2 == 0) {
k = k - (k / n) * n;
} else {
k = k - ((k / n) - 1) * n;
}
} else {
break;
}
}
}
}
cout << n << " " << k;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, K;
int CtoI(int x) {
if (x == 'R') return 1;
if (x == 'Y') return 2;
if (x == 'B') return 3;
if (x == 'W') return 0;
}
int ItoC(int x) {
if (x == 1) return 'R';
if (x == 2) return 'Y';
if (x == 3) return 'B';
if (x == 0) return '.';
}
int ar[2005], mt[2005][2][2], cx[2005], cy[2005];
bitset<2005> a[2005];
int main() {
scanf("%d%d", &n, &K);
for (int i = (0), LIM = (n - 1); i <= LIM; i++) mt[i][0][0] = mt[i][1][1] = 1;
for (int i = (0), LIM = (K - 1); i <= LIM; i++) {
int m, x, cl;
char ch[10], col[2];
scanf("%s", ch);
scanf("%d", &m);
for (int j = (1), LIM = (m); j <= LIM; j++) scanf("%d", &ar[j]), ar[j]--;
if (ch[0] == 'm') {
scanf("%s", col);
cl = CtoI(col[0]);
for (int j = (1), LIM = (m); j <= LIM; j++) {
if (mt[ar[j]][0][0]) a[i << 1][ar[j] << 1] = a[i << 1][ar[j] << 1] ^ 1;
if (mt[ar[j]][0][1])
a[i << 1 | 1][ar[j] << 1] = a[i << 1 | 1][ar[j] << 1] ^ 1;
if (mt[ar[j]][1][0])
a[i << 1][ar[j] << 1 | 1] = a[i << 1][ar[j] << 1 | 1] ^ 1;
if (mt[ar[j]][1][1])
a[i << 1 | 1][ar[j] << 1 | 1] = a[i << 1 | 1][ar[j] << 1 | 1] ^ 1;
}
a[i << 1][n << 1] = cl & 1;
a[i << 1 | 1][n << 1] = cl & 2;
} else {
int b[2][2] = {};
if (ch[0] == 'R' && ch[1] == 'Y') {
b[1][0] = b[0][1] = 1;
}
if (ch[0] == 'R' && ch[1] == 'B') {
b[0][0] = b[1][1] = b[0][1] = 1;
}
if (ch[0] == 'Y') {
b[0][0] = b[1][1] = b[1][0] = 1;
}
for (int j = (1), LIM = (m); j <= LIM; j++) {
static int c[2][2];
memset(c, 0, sizeof c);
int v = ar[j];
for (int i = (0), LIM = (1); i <= LIM; i++)
for (int j = (0), LIM = (1); j <= LIM; j++)
for (int k = (0), LIM = (1); k <= LIM; k++)
c[i][k] ^= mt[v][i][j] * b[j][k];
for (int i = (0), LIM = (1); i <= LIM; i++)
for (int j = (0), LIM = (1); j <= LIM; j++) mt[v][i][j] = c[i][j];
}
}
}
int r = 0;
for (int i = (0), LIM = (2 * n - 1); i <= LIM; i++) {
if (!a[r][i])
for (int j = (r + 1), LIM = (2 * K - 1); j <= LIM; j++)
if (a[j][i]) {
swap(a[j], a[r]);
break;
}
if (!a[r][i]) {
cx[i] = 2005 - 1;
continue;
}
cx[i] = r;
for (int j = (r + 1), LIM = (2 * K - 1); j <= LIM; j++)
if (a[j][i]) a[j] ^= a[r];
r++;
}
for (int i = (2 * n - 1), LIM = (0); i >= LIM; i--)
if (cx[i] != 2005 - 1) {
for (int j = (i + 1), LIM = (2 * n - 1); j <= LIM; j++)
if (a[cx[i]][j]) a[cx[i]][n << 1] = a[cx[i]][n << 1] ^ a[cx[j]][n << 1];
if (!a[cx[i]][i] && a[cx[i]][n << 1]) {
puts("NO");
return 0;
}
}
for (int i = (r), LIM = (2 * K - 1); i <= LIM; i++)
if (a[i][n << 1]) {
puts("NO");
return 0;
}
puts("YES");
for (int i = (0), LIM = (n - 1); i <= LIM; i++) {
int cl = a[cx[i << 1]][n << 1] | (a[cx[i << 1 | 1]][n << 1] << 1);
putchar(ItoC(cl));
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 42;
int n, changes, SZ;
int help[nmax], pointer = 0;
pair<long long, long long> dp[nmax];
deque<int> active, idle;
void eval(long long cost) {
active = idle;
dp[0] = {0, 0};
for (int i = 1; i <= pointer; i++) {
dp[i] = {dp[i - 1].first + 1, dp[i - 1].second};
while (active.size() && help[i] - help[active.front()] + 1 > SZ)
active.pop_front();
while (active.size() && dp[active.back() - 1] >= dp[i - 1])
active.pop_back();
active.push_back(i);
pair<long long, long long> cur = dp[active.front() - 1];
cur.first += cost;
cur.second++;
dp[i] = min(dp[i], cur);
}
}
int solve(vector<int> inp) {
if (inp.size() <= changes) return 0;
pointer = 0;
for (auto k : inp) {
pointer++;
help[pointer] = k;
}
long long ok = -1e9, not_ok = 1e9;
eval(ok);
eval(not_ok);
while (not_ok - ok > 1) {
long long av = (ok + not_ok) / 2;
eval(av);
if (dp[pointer].second >= changes)
ok = av;
else
not_ok = av;
}
eval(not_ok);
return dp[pointer].first - 1LL * changes * not_ok;
}
int main() {
cin >> n >> changes >> SZ;
string inp;
cin >> inp;
vector<int> groups[2] = {{}, {}};
for (int i = 0; i < n; i++)
if ('a' <= inp[i] && inp[i] <= 'z')
groups[0].push_back(i);
else
groups[1].push_back(i);
cout << min(solve(groups[0]), solve(groups[1])) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, n, m) for (int i = n; i < m; i++)
#define ll long long int
using namespace std;
int main()
{
int x,y,z,k;
cin >> x >> y >> z >> k;
ll qx[1005] = {}, qy[1005] = {}, qz[1005] = {};
vector<ll> qe;
REP(i,x) {
cin >> qx[i];
}
REP(i, y) {
cin >> qy[i];
}
REP(i, z) {
cin >> qz[i];
}
REP(i,x) {
REP(j,y) {
qe.push_back(qx[i] + qy[j]);
}
}
sort(qe.begin(), qe.end(), greater<ll>());
vector<ll> qr;
REP(i, min(x*y, k)) {
REP(j,z) {
qr.push_back(qe[i] + qz[j]);
}
}
sort(qr.begin(), qr.end(), greater<ll>());
REP(i,k) {
cout << qr[i] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 1e5 + 15;
const int inf = 1e9;
const int maxe = 200000;
char a[30];
int n, b[30];
long long cnt[30];
long long dp[150][150] = {0};
long long fac[maxn + 5], inv[maxn + 5], dp2[30][30][30];
long long ans = 0;
long long powmod(long long a, long long b, long long mod) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b = b / 2;
}
return ans;
}
void solve() {
fac[0] = 1;
for (int i = 1; i <= maxn; i++) fac[i] = fac[i - 1] * i % mod;
inv[maxn] = powmod(fac[maxn], mod - 2, mod);
for (int i = maxn - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
void init() {
solve();
dp[0][0] = 1;
for (int i = 1; i <= 12; i++)
for (int j = 0; j <= 12; j++) {
dp[i][j] = (dp[i - 1][j] * 8 + dp[i - 1][j - 1] * 2) % mod;
}
}
void dfs(int id, int num) {
if (id > n) {
cnt[num] = (cnt[num] + 1) % mod;
return;
}
if (b[id] == 4 || b[id] == 7)
dfs(id + 1, num + 1);
else
dfs(id + 1, num);
for (int i = b[id] - 1; i >= 0; i--) {
int z = num;
if (i == 4 || i == 7) z++;
int now = n - id;
for (int j = z; j < 15; j++) cnt[j] = (cnt[j] + dp[now][j - z]) % mod;
}
}
long long C(long long n, long long m) {
n %= mod;
long long ans = 1;
for (int i = 0; i < m; i++) ans = ans * (n - i) % mod;
return ans * inv[m] % mod;
}
void go() {
dp2[0][0][0] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= min(cnt[i], (long long)6); j++) {
long long now = C(cnt[i], j);
for (int x = 0; x + j <= 6; x++)
for (int y = 0; y + j * i <= n; y++)
if (dp2[i][x][y]) {
dp2[i + 1][x + j][y + j * i] =
(dp2[i][x][y] * now % mod + dp2[i + 1][x + j][y + j * i]) % mod;
}
}
}
for (int i = n - 1; i >= 0; i--) cnt[i] = (cnt[i] + cnt[i + 1]) % mod;
for (int i = 0; i <= n; i++) {
long long now = dp2[n + 1][6][i] * 720 % mod;
ans += now * cnt[i + 1] % mod;
ans %= mod;
}
}
int main() {
init();
scanf("%s", a);
n = strlen(a);
for (int i = 0; i < n; i++) b[i + 1] = a[i] - '0';
dfs(1, 0);
n += 5;
cnt[0]--;
go();
printf("%I64d\n", ans % mod);
}
| 2 |
#include<cstdio>
int main(void){
int n;
int a[5555];
int k=0;
bool v;
for(int i=1;i<5556;i++){
v=true;
for(int j=3;j<(10*i+1);j+=2){
if((10*i+1)%j==0)v=false;
}
if(v){
a[k]=(10*i)+1;
k++;
}
}
k=0;
scanf("%d",&n);
while(n>0){
printf("%d",a[k]);
if(n>1)printf(" ");
else printf("\n");
n--;
k++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long n, k, a[N], pre[N], suf[N], ans = 1e18;
map<long long, long long> mp;
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
}
for (long long i = n; i >= 1; --i) {
suf[i] = suf[i + 1] + a[i];
}
for (long long i = 1; i <= n; i++) mp[a[i]]++;
for (auto i : mp)
if (i.second >= k) {
cout << 0 << endl;
return 0;
}
for (long long i = 1; i <= n; i++) {
long long x = a[i];
long long e =
upper_bound(a + 1, a + n + 1, x) - lower_bound(a + 1, a + n + 1, x);
long long g = n - (upper_bound(a + 1, a + n + 1, x) - a) + 1;
long long l = lower_bound(a + 1, a + n + 1, x) - a - 1;
long long sg = suf[n - g + 1];
long long sl = pre[l];
long long tmp = sg - g * x + l * x - sl - (n - k);
ans = min(ans, tmp);
if (n - l >= k) {
long long tx = sg - g * x - (n - l - k);
ans = min(ans, tx);
}
if (n - g >= k) {
long long tx = l * x - sl - (n - g - k);
ans = min(ans, tx);
}
}
cout << max(0ll, ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[200010], b[200010];
int sz;
bool equivalent(int al, int ar, int bl, int br) {
if ((ar - al + 1) & 1) {
for (int i = al, j = bl; i <= ar; ++i, ++j)
if (a[i] != b[j]) return false;
return true;
}
bool ans = false;
ans |= (equivalent(al, (al + ar) / 2, bl, (bl + br) / 2) &&
equivalent((al + ar) / 2 + 1, ar, (bl + br) / 2 + 1, br));
if (ans) return ans;
ans |= (equivalent(al, (al + ar) / 2, (bl + br) / 2 + 1, br) &&
equivalent((al + ar) / 2 + 1, ar, bl, (bl + br) / 2));
return ans;
}
int main() {
scanf("%s", a);
scanf("%s", b);
sz = strlen(a);
if (equivalent(0, sz - 1, 0, sz - 1)) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (scanf("%d", &n) == 1) {
if (n < 13)
cout << (1LL << n) << endl;
else
cout << (8092LL << (n - 13)) << endl;
}
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
using ll=long long;
using ull=unsigned long long;
typedef pair<int,int>Pi;
typedef pair<long long,long long>P;
typedef pair<long long,P>PP;
typedef pair<P,P>PPP;
const long long MOD=1e9+7;
const long long INF=5e18;
const int di[4]={1,0,-1,0};
const int dj[4]={0,1,0,-1};
#define fr first
#define sc second
#define pb push_back
#define eb emplace_back
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
int n,a[100010],b[100010];
int zip[200010];
int ans;
vector<int>v;
void input(){
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i]>>b[i];
v.eb(a[i]);
v.eb(b[i]);
}
return;
}
void solve(){
sort(ALL(v));
v.erase(unique(ALL(v)),v.end());
for(int i=0;i<n;i++){
int st=lower_bound(ALL(v),a[i])-v.begin();
int go=lower_bound(ALL(v),b[i]+1)-v.begin();
zip[st]++;
zip[go]--;
}
for(int i=0;i<200005;i++){
zip[i+1]+=zip[i];
ans=max(ans,zip[i]);
}
cout<<ans<<endl;
return;
}
int main(){
input();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[505];
long long ans;
void check(int x) {
long long sum = 0;
for (int i = (int)(1); i <= (int)(n); i++) {
int s1 = (x - a[i] % x) % x;
if (1ll * s1 * (x - 1) > a[i]) return;
sum += s1 + (a[i] - 1ll * s1 * (x - 1)) / x;
}
ans = min(ans, sum);
}
int main() {
scanf("%d", &n);
ans = 1ll << 60;
for (int i = (int)(1); i <= (int)(n); i++) scanf("%d", &a[i]);
for (int i = 1; i * i <= a[1]; i++) {
check(i);
check(i + 1);
check(a[1] / i);
check(a[1] / i + 1);
}
cout << ans << endl;
}
| 5 |
#include<cstdio>
#include<cmath>
using namespace std;
int main(){
long x,y;
scanf("%ld %ld",&x,&y);
if(abs(x-y)>1)
printf("Alice\n");
else
printf("Brown\n");
}
| 0 |
#include <iostream>
#include <utility>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
int main()
{
int a, L;
while(cin >> a >> L, (a|L)) {
map<int, int> m;
int idx = 0;
for(;;) {
string str = to_string(a);
if( m.find(a) != m.end() ) {
int v = m[a];
cout << v << " " << a << " " << (idx - v) << endl;
break;
}
m[a] = idx++;
while(str.size() < (unsigned long)L) {
str.append("0");
}
string left( str ); sort(left.begin(), left.end(), greater<char>());
string right( str ); sort(right.begin(), right.end());
a = stoi(left) - stoi(right);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool sortbysecinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
bool sortbysize(string &s1, string &s2) { return s1.size() < s2.size(); }
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortcol(const vector<int> &v1, const vector<int> &v2) {
return v1[0] < v2[0];
}
long long proceed() {
long long l, r, m, i, mn = 1e15, a;
cin >> l >> r >> m;
for (i = l; i <= r; ++i) {
if (i <= m) {
long long x = m % i;
if (x < mn) mn = x, a = i;
}
long long y = i - m % i;
if (y < mn) mn = y, a = i;
}
(m + mn) % a == 0 ? cout << a << " " << l << " " << l + mn << "\n"
: cout << a << " " << l + mn << " " << l << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1, i = 0;
cin >> t;
while (t--) {
proceed();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
double x1[1010], x2[1010], y11[1010], y2[1010];
double cubic(double x) { return x * x * x; }
int main() {
int n;
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++)
scanf("%lf%lf%lf%lf", &x1[i], &y11[i], &x2[i], &y2[i]);
bool find = false;
for (int i = 0; i < n; i++) {
bool ok = true;
for (int j = 0; j < i; j++) {
double tx = 0, ty = 0, tm = 0;
for (int k = j + 1; k <= i; k++) {
double tnum = cubic(fabs(x2[k] - x1[k]));
tx += (x1[k] + x2[k]) * tnum;
ty += (y11[k] + y2[k]) * tnum;
tm += tnum;
}
tx /= tm;
ty /= tm;
if (!(fabs(tx - x1[j] - x2[j]) <= fabs(x2[j] - x1[j]) &&
fabs(ty - y11[j] - y2[j]) <= fabs(x2[j] - x1[j])))
ok = false;
}
if (!ok) {
printf("%d\n", i);
find = true;
break;
}
}
if (!find) printf("%d\n", n);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 110000;
const int M = 10000000;
using namespace std;
int mu[M + 10], pw[M + 31], cnt[M + 10];
int ans;
int mult(int a, int b) { return 1ll * a * b % 1000000007; }
int add(int a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
return a;
}
int main() {
ios_base::sync_with_stdio(0);
pw[0] = 1;
for (int i = 1; i <= M; i++) pw[i] = pw[i - 1] * 2 % 1000000007;
mu[1] = 0;
for (int i = 2; i <= M; i++) {
if (mu[i] == 0) {
for (int j = i; j <= M; j += i) mu[j]++;
}
}
for (int i = 2; i <= M; i++) {
if (mu[i] % 2 == 1) {
mu[i] = 1;
} else {
mu[i] = -1;
}
}
for (int i = 2; i * i <= M; i++) {
for (int j = i * i; j <= M; j += i * i) {
mu[j] = 0;
}
}
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int val;
cin >> val;
cnt[val]++;
}
for (int G = 2; G <= M; G++) {
if (mu[G] == 0) continue;
int s = 0;
for (int i = G; i <= M; i += G) {
s += cnt[i];
}
if (s == 0) continue;
int rem = n - s;
if (mu[G] == 1) {
ans = add(ans, mult(rem, pw[s] - 1));
} else {
ans = add(ans, 1000000007 - mult(rem, pw[s] - 1));
}
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Maxflow {
struct edge {
int from, to;
long long flow, capacity;
};
int s, t;
vector<edge> edg;
vector<int> g[10111];
int dist[10111], visited[10111];
int cur[10111];
void init() {
edg.clear();
int i;
for (i = 0; i < 10111; i++) {
g[i].clear();
}
}
void addedge(int from, int to, long long capacity) {
edge e1 = edge{from, to, 0ll, capacity};
edge e2 = edge{to, from, 0ll, 0ll};
edg.push_back(e1), edg.push_back(e2);
g[from].push_back((int)edg.size() - 2);
g[to].push_back((int)edg.size() - 1);
}
bool bfs() {
memset(visited, 0, sizeof(visited));
memset(dist, 0, sizeof(dist));
queue<int> q;
q.push(s);
visited[s] = 1;
dist[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < (int)g[v].size(); i++) {
edge &e = edg[g[v][i]];
int nxt = e.to;
if (!visited[nxt] && e.capacity > e.flow) {
dist[nxt] = dist[v] + 1;
q.push(nxt);
visited[nxt] = 1;
}
}
}
return visited[t];
}
long long dfs(int x, long long cp) {
if (x == t || cp == 0) {
return cp;
}
long long flow = 0, newflow;
for (int &y = cur[x]; y < (int)g[x].size(); y++) {
edge &e = edg[g[x][y]];
if (dist[x] + 1 == dist[e.to]) {
long long minn = min(cp, e.capacity - e.flow);
newflow = dfs(e.to, minn);
if (newflow > 0) {
e.flow += newflow;
edg[g[x][y] ^ 1].flow -= newflow;
flow += newflow;
cp -= newflow;
if (cp == 0) {
break;
}
}
}
}
return flow;
}
long long Dinic() {
long long flow = 0;
while (bfs()) {
memset(cur, 0, sizeof(cur));
flow += dfs(s, 1000000000000ll);
}
return flow;
}
};
Maxflow mf;
int n, b, q;
pair<int, int> v[10111];
int cnt(int x, int mod) {
if (x < mod) return 0;
return (x - mod) / 5 + 1;
}
int count(int l, int r, int mod) {
int ret = cnt(r, mod) - cnt(l - 1, mod);
return ret;
}
int main() {
int i, j;
scanf("%d%d%d", &n, &b, &q);
if (n % 5) {
printf("unfair\n");
return 0;
}
for (i = 1; i <= q; ++i) {
scanf("%d%d", &v[i].first, &v[i].second);
}
sort(v + 1, v + 1 + q);
mf.s = 0, mf.t = 10111 - 1;
int d[6];
for (i = 1; i <= 5; ++i) {
d[i] = mf.t - i - 1;
mf.addedge(mf.s, d[i], n / 5);
}
for (i = 1; i <= q; ++i) {
if (i == 1) {
for (j = 1; j <= 5; ++j) {
mf.addedge(d[j], i, count(1, v[i].first, j));
}
mf.addedge(i, mf.t, v[i].second);
continue;
}
if (i > 1 && v[i].first == v[i - 1].first) {
if (v[i].second != v[i - 1].second) {
printf("unfair\n");
return 0;
}
continue;
}
if (v[i].second < v[i - 1].second) {
printf("unfair\n");
return 0;
}
for (j = 1; j <= 5; ++j) {
mf.addedge(d[j], i, count(v[i - 1].first + 1, v[i].first, j));
}
mf.addedge(i, mf.t, v[i].second - v[i - 1].second);
}
if (v[q].first < b) {
for (j = 1; j <= 5; ++j) {
mf.addedge(d[j], q + 1, count(v[q].first + 1, b, j));
}
mf.addedge(q + 1, mf.t, n - v[q].second);
if (v[q].second > n) {
printf("unfair\n");
return 0;
}
}
auto p = mf.Dinic();
for (auto e : mf.edg) {
if (e.from <= q && e.to == mf.t && e.flow != e.capacity) {
printf("unfair\n");
return 0;
}
}
printf("%s\n", p == n ? "fair" : "unfair");
return 0;
}
| 6 |
#include<iostream>
#include<string>
using namespace std;
string hyo[]={".,!? ",
"abc",
"def",
"ghi",
"jkl",
"mno",
"pqrs",
"tuv",
"wxyz",};
int main(){
string in;
int n;
cin>>n;
while(n--){
cin>>in;
string out;
int zen='0';
int c=0;
for(int i=0;i<in.size();i++){
if(in[i]=='0' && zen!='0'){
zen-='1';
int s=hyo[zen].size();
--c;
c%=s;
out+=hyo[zen][c];
c=0;
zen=in[i];
}else if(in[i]=='0' && zen=='0'){
continue;
}else if(zen=='0' && in[i]!=0){
c=1;
zen=in[i];
}else if(in[i]==zen){
++c;
}
}
cout<<out<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ind[10][100100];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<vector<int> > v(10);
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
int in;
cin >> in;
--in;
ind[j][in] = i;
v[j].push_back(in);
}
}
int start = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
int len = i - start;
bool flag = true;
for (int j = 1; j < m; j++) {
if (ind[j][v[0][i]] - ind[j][v[0][start]] != len) {
flag = false;
break;
}
}
if (flag) {
ans += len + 1;
} else {
ans += 1;
start = i;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<long long, bool> vetor;
set<long long> chosen;
void c_stack(stack<long long>& s) {
while (!s.empty()) s.pop();
}
vetor optimal_start(long long N) {
stack<long long> steps;
c_stack(steps);
long long i = 1, j = N;
while (j > i) {
long long mid = (i + j) >> 1;
steps.push(mid);
i = mid + 1;
}
bool rightwise = true;
long long current = 1;
while (!steps.empty()) {
long long now_ = steps.top();
steps.pop();
if (rightwise)
current += now_;
else
current -= now_;
rightwise = !rightwise;
}
return {current, rightwise};
}
vetor aproximation(long long past, long long target, long long mid,
long long N) {
if (chosen.find(target) == chosen.end() && target > past && 1 <= target &&
target <= N)
return {target, true};
if (chosen.find(target) == chosen.end() && target < past && 1 <= target &&
target <= N)
return {target, false};
long long increases = max(target, (long long)1), decreases = min(target, N);
while (increases <= N && chosen.find(increases) != chosen.end()) increases++;
while (decreases >= 1 && chosen.find(decreases) != chosen.end()) decreases--;
if (decreases < 1 && increases > past) return {increases, true};
if (decreases < 1 && increases < past) return {increases, false};
if (increases > N && decreases > past) return {decreases, true};
if (increases > N && decreases < past) return {decreases, false};
long long dif_inc = max(increases - past, past - increases),
dif_dec = max(decreases - past, past - decreases);
if (max(dif_inc - mid, mid - dif_inc) < max(dif_dec - mid, mid - dif_dec)) {
if (increases > past)
return {increases, true};
else
return {increases, false};
} else {
if (decreases > past)
return {decreases, true};
else
return {decreases, false};
}
}
void solve() {
chosen.clear();
long long N;
cin >> N;
vetor vet = optimal_start(N);
cout << "? " << vet.first << endl;
chosen.insert(vet.first);
int _;
cin >> _;
long long i = 1, j = N;
while (i < j) {
long long mdl = (i + j) >> 1;
long long targ;
if (vet.second)
targ = mdl + vet.first;
else
targ = vet.first - mdl;
vetor aux = aproximation(vet.first, targ, mdl, N);
long long actual = max(vet.first - aux.first, aux.first - vet.first);
vet = aux;
vet.second = !vet.second;
cout << "? " << vet.first << endl;
chosen.insert(vet.first);
int ans;
cin >> ans;
if (actual < i || actual > j) continue;
if (ans)
j = actual;
else
i = actual + 1;
}
cout << "= " << i << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> t[1000006], tr;
int a[200005], INF = 1e7, n, m, x, y, z;
pair<int, int> comb(pair<int, int> l, pair<int, int> r) {
return make_pair(a[l.first] < a[r.first] ? l.first : r.first,
a[l.second] > a[r.second] ? l.second : r.second);
}
void build(int v, int tl, int tr) {
if (tl == tr)
t[v] = make_pair(tl, tl);
else {
int tm = (tl + tr) >> 1;
build(v + v, tl, tm);
build(v + v + 1, tm + 1, tr);
t[v] = comb(t[v + v], t[v + v + 1]);
}
}
pair<int, int> get(int v, int tl, int tr, int l, int r) {
if (l > r) return make_pair(n, n + 1);
if (tl == l && tr == r) return t[v];
int tm = (tl + tr) >> 1;
return comb(get(v + v, tl, tm, l, min(r, tm)),
get(v + v + 1, tm + 1, tr, max(l, tm + 1), r));
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> a[i];
a[n] = INF;
a[n + 1] = -INF;
build(1, 0, n - 1);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &x, &y, &z);
tr = get(1, 0, n - 1, x - 1, y - 1);
if (a[tr.first] != z)
printf("%d\n", tr.first + 1);
else if (a[tr.second] != z)
printf("%d\n", tr.second + 1);
else
printf("-1\n");
}
}
| 3 |
#include<iostream>
#include<algorithm>
using namespace std;
// 262144 = 2^18
int tree[262144];
int dfs(int a,int b,int k,int l,int r){
if(r<a || b<l)return 0;
if(a<=l && r<=b)return tree[k];
int m=(l+r)/2;
return dfs(a,b,k*2+1,l,m)+dfs(a,b,k*2+2,m+1,r);
}
int getSum(int a,int b){
// 131072 = 2^17
return dfs(a,b,0,0,131071);
}
void update(int i,int x){
// 131072 = 2^17
i+=(131072-1);
tree[i]+=x;
while(i){
i=(i-1)/2;
tree[i]+=x;
}
}
int n,q;
int a,b,c;
int main(){
cin>>n>>q;
for(int i=0;i<q;i++){
cin>>a>>b>>c;
if(a==1){
cout<<getSum(b,c)<<endl;
}else{
update(b,c);
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using int64 = long long;
struct UnionFind {
vector< int > data;
UnionFind(int sz) {
data.assign(sz, -1);
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if(x == y) return (false);
if(data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if(data[k] < 0) return (k);
return (data[k] = find(data[k]));
}
int size(int k) {
return (-data[find(k)]);
}
};
int main() {
int N, M;
bool mat[100][100] = {{}};
int deg[100] = {};
cin >> N >> M;
UnionFind uf(N);
for(int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
--x, --y;
uf.unite(x, y);
mat[x][y] = true;
mat[y][x] = true;
deg[y] ^= 1;
deg[x] ^= 1;
}
bool update = true;
vector< pair< int, int > > es;
vector< int > rots;
for(int i = 0; i < N; i++) {
if(uf.find(i) == i) rots.push_back(i);
}
for(int i = 0; i + 1 < rots.size(); i++) {
deg[rots[i]] ^= 1;
deg[rots[(i + 1) % rots.size()]] ^= 1;
mat[rots[i]][rots[(i + 1) % rots.size()]] = true;
mat[rots[(i + 1) % rots.size()]][rots[i]] = true;
es.emplace_back(minmax(rots[i], rots[(i + 1) % rots.size()]));
}
while(update) {
queue< int > que;
vector< int > v(N, -1);
vector< int > pv(N, -1);
int select = -1;
for(int i = 0; i < N; i++) {
if(deg[i]) {
v[i] = 0;
deg[i] ^= 1;
que.emplace(i);
select = i;
break;
}
}
if(select == -1) break;
while(que.size()) {
int p = que.front();
que.pop();
for(int i = 0; i < N; i++) {
if(p == i) continue;
if(mat[i][p]) continue;
if(v[i] == -1) {
v[i] = v[p] + 1;
pv[i] = p;
que.emplace(i);
}
}
}
vector< pair< int, int > > ex;
for(int i = 0; i < N; i++) {
if(deg[i] && ~v[i]) {
ex.emplace_back(v[i], i);
}
}
sort(begin(ex), end(ex));
if(ex.size()) {
deg[ex[0].second] ^= 1;
int cur = ex[0].second;
while(cur != select) {
es.emplace_back(minmax(cur, pv[cur]));
mat[cur][pv[cur]] = true;
mat[pv[cur]][cur] = true;
cur = pv[cur];
}
update = true;
} else {
break;
}
}
for(int i = 0; i < N; i++) {
if(deg[i]) {
cout << -1 << endl;
return 0;
}
}
cout << es.size() << endl;
for(auto &p : es) cout << p.first + 1 << " " << p.second + 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m,x;
cin>>n>>m;
int a[n][2],b[n],c[m][2],d[n];
for(int i=0;i<n;i++){
for(int j=0;j<2;j++){
cin>>a[i][j];
}
}
for(int i=0;i<m;i++){
for(int j=0;j<2;j++){
cin>>c[i][j];
}
}
for(int k=0;k<n;k++){;
for(int l=0;l<m;l++){
x=abs(a[k][0]-c[l][0])+abs(a[k][1]-c[l][1]);
if(b[k]>x||l==0) {b[k]=x; d[k]=l+1;}
}
}
for(int y=0;y<n;y++){
cout<<d[y]<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
int main() {
int n; cin >> n;
vector<vector<int>> M(n, vector<int>(n));
rep(i, n) {
int u, k; cin >> u >> k;
rep(z, k) {
int num; cin >> num;
M.at(i).at(num - 1) = 1;
}
}
rep(i, n){
rep(j, n-1)cout << M.at(i).at(j) << " ";
cout << M.at(i).at(n-1) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int s = (i * (5 + i * 5)) / 2;
if (s + k <= 240) {
cnt++;
}
}
cout << cnt << endl;
return 0;
}
| 1 |
#include<cstdio>
long long a, b, c, flag;
int main()
{
scanf("%lld%lld%lld",&a, &b, &c);
if(b>=a){printf("1\n");return 0;}
else if(c >= b) {printf("-1\n");return 0;}
if((a-b)%(b-c) >= 1) flag = 1;
printf("%lld\n",((a-b)/(b-c)+flag)*2+1);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void fastIO() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
template <typename T, typename U>
inline void mnze(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void mxze(T &x, U y) {
if (x < y) x = y;
}
void _scan(int &x) { scanf("%d", &x); }
void _scan(long long &x) { scanf("%lld", &x); }
void _scan(double &x) { scanf("%lf", &x); }
void _scan(char &x) { scanf(" %c", &x); }
void _scan(char *x) { scanf("%s", x); }
void scan() {}
template <typename T, typename... U>
void scan(T &head, U &...tail) {
_scan(head);
scan(tail...);
}
template <typename T>
void _dbg(const char *sdbg, T h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename T, typename... U>
void _dbg(const char *sdbg, T h, U... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
const long long MOD = 998244353;
const long long MAXM = 2e5 + 5;
long long sq(long long x) { return x * x % MOD; }
long long pot(long long b, long long e) {
return e ? sq(pot(b, e >> 1)) * (e & 1 ? b : 1) % MOD : 1;
}
long long inv2;
long long n, m, A;
long long b[MAXM];
long long ns(long long l) { return pot(A, l); }
long long nps(long long l) {
long long t = ns(l);
long long ret = t + ((t - 1) * t % MOD) * inv2 % MOD;
return ret % MOD;
}
int main() {
inv2 = pot(2, MOD - 2);
scan(n, m, A);
for (int i = 0; i < (int)m; i++) scan(b[i]);
long long ans = 1;
for (int i = 0; i < (int)m; i++) {
long long l;
if (i)
l = b[i] - b[i - 1];
else
l = b[i];
ans *= nps(l);
ans %= MOD;
}
long long l = n - 2 * b[m - 1];
ans *= ns(l);
ans %= MOD;
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
inline char readLetter() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z')) {
c = getchar();
}
return c;
}
inline int read() {
char c = getchar();
int n = 0, f = 0;
while (c < '0' || c > '9') {
if (c == '-') {
f = 1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
n = (n << 1) + (n << 3) + (c & 15);
c = getchar();
}
return f ? -n : n;
}
const int maxInt = 2147483647;
const long long maxLongLong = 9223372036854775807LL;
const int maxN = 505;
const int p = 998244353;
const int inv = 998244353 / 2 + 1;
int n, k, f[maxN][maxN], cnt[maxN];
long long ans;
int main() {
std::cin >> n >> k;
for (int i = 1; i <= n; i++) {
memset(f, 0, sizeof(f));
f[1][1] = 5 / 2;
for (int j = 2; j <= n; j++) {
for (int k = 1; k <= std::min(i, j); k++) {
f[j][1] += f[j - 1][k];
f[j][1] %= p;
if (k != 1) f[j][k] = f[j - 1][k - 1];
}
}
for (int j = 1; j <= i; j++) {
cnt[i] += f[n][j];
cnt[i] %= p;
}
}
for (int i = n; i >= 1; i--) {
cnt[i] = cnt[i] - cnt[i - 1];
cnt[i] = (cnt[i] % p + p) % p;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i * j >= k) break;
ans += 1LL * cnt[i] * cnt[j] % p * inv % p;
ans %= p;
}
}
std::cout << ans << std::endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
void print(vector<long long> &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld ", v[i]);
}
printf("\n");
}
void print(vector<pair<long long, long long> > &v) {
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
printf("%lld %lld\n", v[i].first, v[i].second);
}
}
void print(double d) { cout << fixed << setprecision(10) << d << endl; }
void print(string s, double d) {
cout << s << " ";
cout << fixed << setprecision(10) << d << endl;
}
const int N = 505;
string s[N];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
struct c {
int x, y;
char c;
void print() { printf("%c %d %d\n", c, x, y); }
void change(int x1, int y1, char c1) {
x = x1;
y = y1;
c = c1;
}
};
vector<c> v;
bool vis[N][N];
long long n, m;
void dfs(int x, int y) {
vis[x][y] = 1;
for (int k = 0; k < 4; k++) {
int xx = dx[k] + x;
int yy = dy[k] + y;
if (xx >= 0 and xx < n and yy >= 0 and yy < m and s[xx][yy] == 'B' and
vis[xx][yy] == 0) {
dfs(xx, yy);
}
}
c tt;
tt.change(x + 1, y + 1, 'D');
v.push_back(tt);
tt.change(x + 1, y + 1, 'R');
v.push_back(tt);
}
int main() {
long long q, i, j = 0, temp, t, k, ans = 0, sum = 0, x, y, z, cnt = 0, fg = 0,
mx = 0, mx1 = 0, mn = 8000000000000000000,
mn1 = 8000000000000000000;
scanf("%lld %lld", &n, &m);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
c tt;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
tt.c = 'B';
tt.x = i + 1;
tt.y = j + 1;
v.push_back(tt);
s[i][j] = 'B';
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'B' and vis[i][j] == 0) {
vis[i][j] = 1;
for (int k = 0; k < 4; k++) {
int xx = i + dx[k];
int yy = j + dy[k];
if (xx >= 0 and xx < n and yy >= 0 and yy < m and s[xx][yy] == 'B' and
vis[xx][yy] == 0) {
dfs(xx, yy);
}
}
}
}
}
cout << v.size() << endl;
for (c kk : v) {
kk.print();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sc[200010];
int path[200010];
int vis[200010];
int q[1000000];
void bfs() {
int first = 0, rear = 0, cot = 0;
q[rear++] = 1;
vis[1] = 1;
path[1] = 0;
while (first < rear) {
int t = q[first++];
if (!vis[t + 1]) {
vis[t + 1] = 1;
path[t + 1] = path[t] + 1;
q[rear++] = t + 1;
}
if (t - 1 > 0 && !vis[t - 1]) {
vis[t - 1] = 1;
path[t - 1] = path[t] + 1;
q[rear++] = t - 1;
}
if (!vis[sc[t]]) {
vis[sc[t]] = 1;
path[sc[t]] = path[t] + 1;
q[rear++] = sc[t];
}
}
return;
}
int main() {
int n;
while (cin >> n) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
cin >> sc[i];
}
bfs();
for (int i = 1; i < n; i++) {
cout << path[i] << " ";
}
cout << path[n] << endl;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int N,K;
int main () {
cin >> N >> K;
double ans = 0;
for(int i=1; i<=N; i++) {
double p = (double)1/N;
for(int j=i; j<K; j*=2) p*=0.5;
ans += p;
}
printf("%.12f\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
int ans;
cin >> x >> y;
if (x.compare(y) != 0)
ans = max(x.length(), y.length());
else
ans = -1;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void Rd(int &res) {
res = 0;
char p;
while (p = getchar(), p < '0')
;
do {
res = (res * 10) + (p ^ 48);
} while (p = getchar(), p >= '0');
}
void Max(int &x, int y) {
if (x < y) x = y;
}
struct W {
int to, nx, d;
} Lis[100005 << 1];
int Head[100005], tot = 1;
void Add(int x, int y, int d) {
Lis[tot].to = y, Lis[tot].nx = Head[x], Lis[tot].d = d;
Head[x] = tot++;
}
int n, P;
long long ans;
int q[100005], sz, cntson[100005], Mxson[100005], phi;
int fast(int x, int p) {
int re = 1;
while (p) {
if (p & 1) re = (long long)re * x % P;
x = (long long)x * x % P, p >>= 1;
}
return re;
}
bool vis[100005];
void dfs_pre(int x, int f) {
cntson[x] = 1, Mxson[x] = 0, q[sz++] = x;
for (int i = Head[x], to; i && (to = Lis[i].to, 1); i = Lis[i].nx)
if (to != f && !vis[to])
dfs_pre(to, x), cntson[x] += cntson[to], Max(Mxson[x], cntson[to]);
}
map<pair<int, int>, int> mp;
map<int, int> pm;
void dfs_pro(int x, int f, int v1, int c, int v2, int fac) {
mp[pair<int, int>(v1, c)]++, pm[v2]++;
for (int i = Head[x], to; i && (to = Lis[i].to, 1); i = Lis[i].nx)
if (to != f && !vis[to])
dfs_pro(to, x, (v1 * 10LL + Lis[i].d) % P, c + 1,
(v2 + (long long)fac * Lis[i].d) % P, fac * 10LL % P);
}
void dfs_sml(int x, int f, int v) {
if (v == 0) ans++;
for (int i = Head[x], to; i && (to = Lis[i].to, 1); i = Lis[i].nx)
if (to != f && !vis[to]) dfs_sml(to, x, (v * 10LL + Lis[i].d) % P);
}
void dfs(int x) {
sz = 0;
dfs_pre(x, x);
if (sz <= 400) {
for (int i = 0; i < sz; i++) dfs_sml(q[i], q[i], 0), ans--;
return;
}
int pl = cntson[x], rt = x;
for (int i = 0; i < sz; i++) {
int p = q[i];
Max(Mxson[p], cntson[x] - cntson[p]);
if (Mxson[p] < pl) pl = Mxson[p], rt = p;
}
mp.clear(), pm.clear();
dfs_pro(rt, rt, 0, 0, 0, 1);
ans--;
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end();
it++) {
int lp = (long long)(P - (it->first).first) *
fast(fast(10, (it->first).second), phi) % P;
map<int, int>::iterator it1 = pm.find(lp);
if (it1 != pm.end()) ans += (long long)(it->second) * (it1->second);
}
for (int i = Head[rt], to; i && (to = Lis[i].to, 1); i = Lis[i].nx)
if (!vis[to]) {
mp.clear(), pm.clear();
dfs_pro(to, rt, Lis[i].d % P, 1, Lis[i].d % P, 10 % P);
for (map<pair<int, int>, int>::iterator it = mp.begin(); it != mp.end();
it++) {
int lp = (long long)(P - (it->first).first) *
fast(fast(10, (it->first).second), phi) % P;
map<int, int>::iterator it1 = pm.find(lp);
if (it1 != pm.end()) ans -= (long long)(it->second) * (it1->second);
}
}
vis[rt] = 1;
for (int i = Head[rt], to; i && (to = Lis[i].to, 1); i = Lis[i].nx)
if (!vis[to]) dfs(to);
}
int main() {
Rd(n), Rd(P);
if (P == 1) {
cout << (long long)n * (n - 1) << endl;
return 0;
}
phi = P;
int t = P;
for (int i = 2; (long long)i * i <= phi; i++)
if (t % i == 0) {
phi = phi / i * (i - 1);
while (t % i == 0) t /= i;
}
if (t > 1) phi = phi / t * (t - 1);
phi--;
for (int i = 1, x, y, z; i < n; i++)
Rd(x), Rd(y), Rd(z), x++, y++, Add(x, y, z), Add(y, x, z);
dfs(1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int l = s.size();
int c1 = 0;
bool fr = true;
for (int i = 0; i < l; i++) {
if (s[i] == '1') c1++;
}
for (int i = 0; i < l; i++) {
if (s[i] == '1') continue;
if (s[i] == '0') {
cout << 0;
} else {
if (fr) {
fr = false;
for (int j = 0; j < c1; j++) cout << 1;
}
cout << 2;
}
}
if (fr) {
for (int j = 0; j < c1; j++) cout << 1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
double k, x;
string s;
map<string, int> mp;
int main() {
ios::sync_with_stdio(false), cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
cin >> s >> x, x *= k, x >= 100 ? mp[s] = int(x + 1e-6) : 0;
for (int i = 1; i <= m; i++) cin >> s, !mp[s] ? mp[s] = 0 : 0;
cout << mp.size() << endl;
for (map<string, int>::iterator i = mp.begin(); i != mp.end(); i++)
cout << (*i).first << " " << (*i).second << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
void solve(){
int n;
cin>>n;
if(n==0) exit(0);
string s;
cin>>s;
int g=0;
for(int i=51;i>=0;i--)if(s[51-i]=='1')g+=(1ll<<i);
int d=1;
n--;
// g/=2;
int zen=(1ll<<53)-1;
int bit=g;
bit+=(1ll<<52);
g+=(1ll<<52);
g/=2;
while(1){
if(n==0) goto lll;
if(g==0) goto lll;
int kai=(zen-bit)/g;
if(kai>=n) {
bit+=n*g;
goto lll;
}
n-=kai;
bit+=kai*g;
d++;
bit=(bit+g)/2;
g/=2;
n--;
if(n==0) goto lll;
}
lll:;
for(int i=11;i>=0;i--){
if(d&(1ll<<i))cout<<"1";
else cout<<"0";
}
for(int i=51;i>=0;i--){
if(bit&(1ll<<i))cout<<"1";
else cout<<"0";
}
cout<<endl;
//cout<<ans<<endl;
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int t;
//cin>>t;
for(int i=0;;i++){
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, char> > vecc[24];
int main() {
vecc[0].push_back(make_pair(0, 'L'));
vecc[0].push_back(make_pair(1, 'R'));
vecc[0].push_back(make_pair(2, 'U'));
vecc[0].push_back(make_pair(3, 'D'));
vecc[1].push_back(make_pair(0, 'L'));
vecc[1].push_back(make_pair(1, 'R'));
vecc[1].push_back(make_pair(2, 'D'));
vecc[1].push_back(make_pair(3, 'U'));
vecc[2].push_back(make_pair(0, 'L'));
vecc[2].push_back(make_pair(1, 'D'));
vecc[2].push_back(make_pair(2, 'U'));
vecc[2].push_back(make_pair(3, 'R'));
vecc[3].push_back(make_pair(0, 'L'));
vecc[3].push_back(make_pair(1, 'D'));
vecc[3].push_back(make_pair(2, 'R'));
vecc[3].push_back(make_pair(3, 'U'));
vecc[4].push_back(make_pair(0, 'L'));
vecc[4].push_back(make_pair(1, 'U'));
vecc[4].push_back(make_pair(2, 'R'));
vecc[4].push_back(make_pair(3, 'D'));
vecc[5].push_back(make_pair(0, 'L'));
vecc[5].push_back(make_pair(1, 'U'));
vecc[5].push_back(make_pair(2, 'D'));
vecc[5].push_back(make_pair(3, 'R'));
vecc[6].push_back(make_pair(0, 'R'));
vecc[6].push_back(make_pair(1, 'L'));
vecc[6].push_back(make_pair(2, 'U'));
vecc[6].push_back(make_pair(3, 'D'));
vecc[7].push_back(make_pair(0, 'R'));
vecc[7].push_back(make_pair(1, 'L'));
vecc[7].push_back(make_pair(2, 'D'));
vecc[7].push_back(make_pair(3, 'U'));
vecc[8].push_back(make_pair(0, 'R'));
vecc[8].push_back(make_pair(1, 'D'));
vecc[8].push_back(make_pair(2, 'U'));
vecc[8].push_back(make_pair(3, 'L'));
vecc[9].push_back(make_pair(0, 'R'));
vecc[9].push_back(make_pair(1, 'D'));
vecc[9].push_back(make_pair(2, 'L'));
vecc[9].push_back(make_pair(3, 'U'));
vecc[10].push_back(make_pair(0, 'R'));
vecc[10].push_back(make_pair(1, 'U'));
vecc[10].push_back(make_pair(2, 'L'));
vecc[10].push_back(make_pair(3, 'D'));
vecc[11].push_back(make_pair(0, 'R'));
vecc[11].push_back(make_pair(1, 'U'));
vecc[11].push_back(make_pair(2, 'D'));
vecc[11].push_back(make_pair(3, 'L'));
vecc[12].push_back(make_pair(0, 'U'));
vecc[12].push_back(make_pair(1, 'R'));
vecc[12].push_back(make_pair(2, 'L'));
vecc[12].push_back(make_pair(3, 'D'));
vecc[13].push_back(make_pair(0, 'U'));
vecc[13].push_back(make_pair(1, 'R'));
vecc[13].push_back(make_pair(2, 'D'));
vecc[13].push_back(make_pair(3, 'L'));
vecc[14].push_back(make_pair(0, 'U'));
vecc[14].push_back(make_pair(1, 'D'));
vecc[14].push_back(make_pair(2, 'L'));
vecc[14].push_back(make_pair(3, 'R'));
vecc[15].push_back(make_pair(0, 'U'));
vecc[15].push_back(make_pair(1, 'D'));
vecc[15].push_back(make_pair(2, 'R'));
vecc[15].push_back(make_pair(3, 'L'));
vecc[16].push_back(make_pair(0, 'U'));
vecc[16].push_back(make_pair(1, 'L'));
vecc[16].push_back(make_pair(2, 'R'));
vecc[16].push_back(make_pair(3, 'D'));
vecc[17].push_back(make_pair(0, 'U'));
vecc[17].push_back(make_pair(1, 'L'));
vecc[17].push_back(make_pair(2, 'D'));
vecc[17].push_back(make_pair(3, 'R'));
vecc[18].push_back(make_pair(0, 'D'));
vecc[18].push_back(make_pair(1, 'R'));
vecc[18].push_back(make_pair(2, 'U'));
vecc[18].push_back(make_pair(3, 'L'));
vecc[19].push_back(make_pair(0, 'D'));
vecc[19].push_back(make_pair(1, 'R'));
vecc[19].push_back(make_pair(2, 'L'));
vecc[19].push_back(make_pair(3, 'U'));
vecc[20].push_back(make_pair(0, 'D'));
vecc[20].push_back(make_pair(1, 'L'));
vecc[20].push_back(make_pair(2, 'U'));
vecc[20].push_back(make_pair(3, 'R'));
vecc[21].push_back(make_pair(0, 'D'));
vecc[21].push_back(make_pair(1, 'L'));
vecc[21].push_back(make_pair(2, 'R'));
vecc[21].push_back(make_pair(3, 'U'));
vecc[22].push_back(make_pair(0, 'D'));
vecc[22].push_back(make_pair(1, 'U'));
vecc[22].push_back(make_pair(2, 'R'));
vecc[22].push_back(make_pair(3, 'L'));
vecc[23].push_back(make_pair(0, 'D'));
vecc[23].push_back(make_pair(1, 'U'));
vecc[23].push_back(make_pair(2, 'L'));
vecc[23].push_back(make_pair(3, 'R'));
long long n, m;
cin >> n >> m;
char cc[n][m];
long long ssx, ssy;
long long ex, ey;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
cin >> cc[i][j];
if (cc[i][j] == 'S') {
ssx = i;
ssy = j;
}
if (cc[i][j] == 'E') {
ex = i;
ey = j;
}
}
string ss;
cin >> ss;
long long anss = 0;
for (long long i = 0; i < 24; i++) {
long long sx = ssx;
long long sy = ssy;
long long flag = 0;
for (long long j = 0; j < ss.length(); j++) {
char ccd = ss[j];
if (vecc[i][(long long)(ccd - 48)].second == 'U') {
sx += 1;
} else if (vecc[i][(long long)(ccd - 48)].second == 'D') {
sx -= 1;
} else if (vecc[i][(long long)(ccd - 48)].second == 'L') {
sy -= 1;
} else if (vecc[i][(long long)(ccd - 48)].second == 'R') {
sy += 1;
}
if (sx < 0 or sx >= n or sy < 0 or sy >= m) {
flag = 1;
break;
} else if (cc[sx][sy] == '#') {
flag = 1;
break;
} else if (sx == ex and sy == ey) {
flag = 2;
break;
}
}
if (flag == 2) anss++;
}
cout << anss << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
using namespace std;
auto clk = clock();
const long double pi = acos(-1.0);
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int digarr[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int alf = 26;
const int dig = 10;
const int two = 2;
const int th = 3;
const long long prost = 239;
const long long btc = 30;
const long double eps = 1e-10;
const long long INF = (long long)(1e18 + 239);
const int BIG = (int)(1e9 + 239);
const int MOD = 998244353;
const long long MOD2 = (long long)MOD * (long long)MOD;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
const int infi = 0x3f3f3f3f;
const int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, s;
cin >> n >> s;
string str, ans;
str = to_string(n);
long long sz = str.length(), sum = 0, flag = 0, i, j;
for (i = 0; str[i]; i++) {
char ch = str[i];
int dig = ch - '0';
ans.push_back(ch);
if (sum + dig > s) {
j = i;
ans[i] = '0';
flag = 1;
break;
} else {
sum += dig;
}
}
int done = 0;
if (flag == 0) {
cout << 0 << '\n';
continue;
} else {
ans[i] = '0';
i--;
if (i >= 0) {
while (i >= 0) {
if (ans[i] - '0' < 9) {
if (sum < s) {
ans[i]++;
sum++;
done = 1;
break;
} else {
sum -= (ans[i] - '0');
ans[i] = '0';
}
} else {
sum -= (ans[i] - '0');
ans[i] = '0';
}
i--;
}
}
if (i < 0 and done == 0) {
ans = "1" + ans;
}
j++;
for (; str[j]; j++) {
ans.push_back('0');
}
}
long long ansll;
ansll = stoll(ans);
cout << ansll - n << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%d", &n);
int arr[n];
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n);
int flag = 0;
for (int i = 0; i <= n - 3; i++) {
if (arr[i] + arr[i + 1] > arr[i + 2]) {
flag = 1;
break;
}
}
if (flag == 1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, k, x, y, t;
cin >> n;
vector<long long> a(n + 5), v[n + 5];
for (i = 1; i <= n; i++) {
cin >> x;
v[n - x].push_back(i);
}
long long cnt = 0;
for (i = 1; i <= n; i++) {
if (v[i].size() % i) {
cout << "Impossible" << endl;
return 0;
}
long long tmp = v[i].size() / i;
for (j = 0; j < tmp; j++) {
cnt++;
for (k = 0; k < i; k++) {
a[v[i].back()] = cnt;
v[i].pop_back();
}
}
}
cout << "Possible" << endl;
for (i = 1; i <= n; i++) cout << a[i] << " ";
cout << endl;
}
| 2 |
#include<bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define D long double
using namespace std;
//typedef long double D;
typedef complex<long double> P;
typedef vector<P> VP;
typedef pair<P, P> L; // Line
typedef vector<P> VP;
const D EPS = 1e-9; // 許容誤差。問題によって変える
#define X real()
#define Y imag()
#define LE(n,m) ((n) < (m) + EPS)
#define GE(n,m) ((n) + EPS > (m))
#define EQ(n,m) (abs((n)-(m)) < EPS)
D dot(P a, P b) {return (conj(a)*b).X; }
D cross(P a, P b) { return (conj(a)*b).Y;}
int ccw(P a, P b, P c) {
b -= a; c -= a;
if (cross(b,c) > EPS) return +1; // counter clockwise
if (cross(b,c) < -EPS) return -1; // clockwise
if (dot(b,c) < -EPS) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line or a==b
return 0; // a--c--b on line or a==c or b==c
}
bool isecSP(P a1, P a2, P b) {
return !ccw(a1, a2, b);
}
P crosspointLL(P a1, P a2, P b1, P b2) {
long double d1 = cross(b2-b1, b1-a1);
long double d2 = cross(b2-b1, a2-a1);
if (EQ(d1, 0) && EQ(d2, 0)) return a1; // same line
if (EQ(d2, 0)) throw "kouten ga nai"; // 交点がない
return a1 + d1/d2 * (a2-a1);
}
P circumcenter(P a, P b, P c) {
a = (a-c)*(long double)0.5;
b = (b-c)*(long double)0.5;
return c + crosspointLL(a, a*P(1,1), b, b*P(1,1));
}
int dp[1<<14],n,m;
D min_s[1<<14];
VP v;
void Mae_syori(){
r(i,(1<<n))min_s[i]=1e15;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
for(int k=j+1;k<n;k++){
if(isecSP(v[i],v[j],v[k]))continue;
if(isecSP(v[i],v[k],v[j]))continue;
if(isecSP(v[k],v[j],v[i]))continue;
P c=circumcenter(v[i],v[j],v[k]);
D ans=0;
ans=max(ans,abs(v[i]-c));
ans=max(ans,abs(v[j]-c));
ans=max(ans,abs(v[k]-c));
int mask=0;
for(int l=0;l<n;l++){
if(abs(v[l]-c)<=ans)mask|=(1<<l);
}
min_s[mask]=min(ans,min_s[mask]);
}
D ans=abs(v[i]-v[j])/2;
P c=(v[i]+v[j]);c/=2;
int mask=0;
for(int l=0;l<n;l++){
if(abs(v[l]-c)<=ans)mask|=(1<<l);
}
min_s[mask]=min(ans,min_s[mask]);
}
}
r(i,n)min_s[(1<<i)]=0;
for(int i=(1<<n)-1;i>=0;i--){
for(int j=(i-1)&i;j>0;j=(j-1)&i){
min_s[j]=min(min_s[j],min_s[i]);
}
}
for(int i=0;i<(1<<n);i++) min_s[i]+=0.0000000001;
}
D dfs(int S){
if(dp[S])return dp[S];
D res=1e8;
for(int i=(S-1)&S;i>0;i=(i-1)&S){
res=min(res,dfs(i)+dfs(i^S));
}
return dp[S]=res;
}
bool check(D mid){
memset(dp,0,sizeof(dp));
for(int i=1;i<(1<<n);i++){
if(min_s[i]<=mid)dp[i]=1;
}
return dfs((1<<n)-1)<=m;
}
D nibutan(){
D l=0,r=100000;
r(i,77){
D mid=(l+r)/2;//cout<<mid<<endl;
if(check(mid))r=mid;
else l=mid;
}
return l;
}
int main(){
cin>>n>>m;
r(i,n){
int x,y;
cin>>x>>y;
v.push_back(P(x,y));
}
Mae_syori();
printf("%.12Lf\n",nibutan());
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100001][2][2];
vector<long long> v;
long long n;
long long fun(long long i, long long sc, long long pc) {
if (i > n - 1) return 0;
if (dp[i][sc][pc] != -1) return dp[i][sc][pc];
if (sc == 1) {
dp[i][sc][pc] = (v[i] * (-1)) + fun(i + 1, sc, pc);
} else if (pc == 1) {
dp[i][sc][pc] = (v[i] * (-1)) + max(fun(i + 1, 0, 1), fun(i + 1, 0, 0));
} else if (pc == 0) {
dp[i][sc][pc] = v[i] + max(fun(i + 1, 0, 0), fun(i + 1, 1, 0));
}
return dp[i][sc][pc];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
memset(dp, -1, sizeof dp);
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
cout << max(fun(0, 0, 1), fun(0, 0, 0));
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
inline int read();
inline long long readl();
inline void write(int x, int ch);
inline void writel(long long x, int ch);
const int maxn = 1e6 + 10;
const int mod = 998244353;
map<pair<int, int>, int> mp;
vector<int> ve[maxn];
int n, m, k;
int c[maxn], a[maxn], b[maxn], f[maxn];
struct Undo_Dsu {
stack<pair<int, int> > st;
int fa[maxn], sz[maxn];
void init() {
while (!st.empty()) st.pop();
for (int i = 1; i <= n * 2 + 1; i++) fa[i] = i, sz[i] = 1;
}
int Find(int x) { return x == fa[x] ? x : Find(fa[x]); }
bool combine(int u, int v) {
int x = Find(u), y = Find(v);
if (x == y) return false;
if (sz[x] > sz[y]) swap(x, y), swap(u, v);
fa[x] = y, sz[y] += sz[x];
st.push({x, y});
return true;
}
void undo() {
pair<int, int> pre = st.top();
fa[pre.first] = pre.first;
sz[pre.second] -= sz[pre.first];
st.pop();
}
} dsu;
signed main() {
long long ans = 0;
n = read(), m = read(), k = read();
dsu.init();
for (int i = 1; i <= n; i++) c[i] = read();
for (int i = 1; i <= m; i++) a[i] = read(), b[i] = read();
for (int i = 1; i <= m; i++) {
if (c[a[i]] == c[b[i]]) {
int u = dsu.Find(a[i]), v = dsu.Find(b[i]);
if (u == v)
f[c[a[i]]] = 1;
else
dsu.combine(a[i], b[i] + n), dsu.combine(b[i], a[i] + n);
}
}
int type = 0;
for (int i = 1; i <= m; i++) {
if (c[a[i]] != c[b[i]] && !f[c[a[i]]] && !f[c[b[i]]]) {
int u = c[a[i]], v = c[b[i]];
if (u > v) swap(u, v);
int id = mp[make_pair(u, v)];
if (!id) id = mp[make_pair(u, v)] = ++type;
ve[id].push_back(i);
}
}
for (auto x : mp) {
int w = x.second;
int now = dsu.st.size();
for (auto vv : ve[w]) {
int uid = a[vv], vid = b[vv];
int fau = dsu.Find(uid), fav = dsu.Find(vid);
if (fau == fav) {
--ans;
break;
}
dsu.combine(uid, vid + n);
dsu.combine(vid, uid + n);
}
while ((int)dsu.st.size() > now) dsu.undo();
}
int cnt = 0;
for (int i = 1; i <= k; i++)
if (!f[i]) cnt++;
ans += 1LL * cnt * (cnt - 1) / 2;
writel(ans, 1);
}
inline void writel(long long x, int ch) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) {
writel(x / 10, 0);
}
putchar(x % 10 + '0');
if (ch) printf("\n");
return;
}
inline void write(int x, int ch) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) {
write(x / 10, 0);
}
putchar(x % 10 + '0');
if (ch) printf("\n");
return;
}
inline long long readl() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 5e3 + 10;
using namespace std;
long long a, b, t, p[maxn];
int kk = 0;
void fj(long long x, long long y) {
if (y == 1) return;
while (x) {
p[kk++] = x % y;
x /= y;
}
}
int ck(long long x, long long m) {
long long ans = 0, s = 1, i = 0;
while (i < kk) {
ans += p[i++] * s;
s *= m;
}
if (ans == x) return 1;
return 0;
}
void xin(long long b, long long a, long long t) {
fj(b, a);
if (ck(a, t))
puts("1");
else
puts("0");
}
int main() {
cin >> t >> a >> b;
if (t == 1) {
if (a == b && b == 1) {
puts("inf");
return 0;
}
if (a > b) {
puts("0");
return 0;
}
long long s = 1;
if (a != 1)
while (s < b) s *= a;
if (s == b)
puts("1");
else
xin(b, a, t);
} else {
if (a == b && b == t)
puts("2");
else if (a == b)
puts("1");
else
xin(b, a, t);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, deg[200010];
set<pair<int, int>> s;
pair<int, int> p[200010];
vector<int> rez;
set<int> v[200010];
map<bool, int> mp[200010];
void rem() {
while (!s.empty() and s.begin()->first < k) {
x = s.begin()->second;
for (auto it : v[x]) {
s.erase({deg[it], it});
--deg[it];
v[it].erase(x);
if (deg[it] > 0) s.insert({deg[it], it});
}
s.erase({deg[x], x});
deg[x] = 0;
v[x].clear();
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> p[i].first >> p[i].second;
deg[p[i].first]++, deg[p[i].second]++;
v[p[i].first].insert(p[i].second), v[p[i].second].insert(p[i].first);
}
for (int i = 1; i <= n; i++) s.insert({deg[i], i});
for (int i = m - 1; i >= 0; i--) {
rem();
rez.push_back((int)s.size());
x = p[i].first, y = p[i].second;
if (deg[x] == 0 or deg[y] == 0) continue;
v[x].erase(y), v[y].erase(x);
s.erase({deg[x], x}), s.erase({deg[y], y});
--deg[x], --deg[y];
if (deg[x] > 0) s.insert({deg[x], x});
if (deg[y] > 0) s.insert({deg[y], y});
}
reverse(rez.begin(), rez.end());
for (auto ans : rez) cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long base = 14012001;
const long long MM = 1ll * 1000000007 * 1000000007;
using namespace std;
int BIT(int i, long long x) { return (x & (1 << i)); }
long long ONBIT(int i, long long x) { return (x | (1 << i)); }
long long OFFBIT(int i, long long x) { return (x & ~(1 << i)); }
long long FLIPBIT(int i, long long x) { return (x ^ (1 << i)); }
long long NUMBIT(long long x) { return __builtin_popcount(x); }
template <class T>
T GCD(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T LCM(T a, T b) {
return a / GCD(a, b) * b;
}
long n, a[1005000], b[1005000];
void read() {
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i];
for (int i = (1); i <= (n); ++i) cin >> b[i];
}
long long resa, resb;
void solve() {
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
long j = n, i = n;
while (i || j) {
if (a[i] > b[j]) {
resa += a[i];
i--;
} else {
j--;
}
if (a[i] < b[j]) {
resb += b[j];
j--;
} else {
i--;
}
}
cout << (resa - resb);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
read();
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char a[1111][1111];
int n, m;
inline bool rect(int sx, int sy, int fx, int fy) {
for (int i = sx; i <= fx; ++i) {
if (a[i][sy] == '.') return 0;
if (a[i][fy] == '.') return 0;
}
for (int j = sy; j <= fy; ++j) {
if (a[sx][j] == '.') return 0;
if (a[fx][j] == '.') return 0;
}
return 1;
}
inline void fill(int sx, int sy, int fx, int fy, char sym) {
for (int i = sx; i <= fx; ++i) {
a[i][sy] = sym;
a[i][fy] = sym;
}
for (int j = sy; j <= fy; ++j) {
a[sx][j] = sym;
a[fx][j] = sym;
}
}
vector<pair<int, int> > col;
inline void check(int sx, int sy, int fx, int fy) {
if (fx - sx < 2) return;
if (fy - sy < 2) return;
if (!rect(sx, sy, fx, fy)) return;
fill(sx, sy, fx, fy, '?');
bool alf = true;
int mnx = 1000000000, mxx = -1000000000, mny = 1000000000, mxy = -1000000000;
for (int i = 0; i < (int)(col).size(); ++i) {
if (a[col[i].first][col[i].second] == '#') {
alf = false;
mnx = min(mnx, col[i].first);
mxx = max(mnx, col[i].first);
mny = min(mny, col[i].second);
mxy = max(mny, col[i].second);
}
}
if (alf) {
cout << "YES\n";
cout << sx + 1 << " " << sy + 1 << " " << fx + 1 << " " << fy + 1 << endl;
cout << sx + 1 << " " << sy + 1 << " " << fx + 1 << " " << fy + 1 << endl;
exit(0);
}
vector<int> xx(0);
xx.push_back(sx);
xx.push_back(fx);
xx.push_back(mnx);
xx.push_back(mxx);
vector<int> yy(0);
yy.push_back(sy);
yy.push_back(fy);
yy.push_back(mny);
yy.push_back(mxy);
sort((xx).begin(), (xx).end());
xx.resize(unique((xx).begin(), (xx).end()) - xx.begin());
sort((yy).begin(), (yy).end());
yy.resize(unique((yy).begin(), (yy).end()) - yy.begin());
for (int ix = 0; ix < (int)(xx).size(); ++ix) {
for (int jx = ix + 1; jx < (int)(xx).size(); ++jx) {
if (xx[jx] - xx[ix] < 2) continue;
for (int iy = 0; iy < (int)(yy).size(); ++iy) {
for (int jy = iy + 1; jy < (int)(yy).size(); ++jy) {
if (yy[jy] - yy[iy] < 2) continue;
bool ok = true;
for (int i = 0; i < (int)(col).size(); ++i) {
if (a[col[i].first][col[i].second] == '#') {
if ((col[i].first == xx[ix] || col[i].first == xx[jx]) &&
col[i].second >= yy[iy] && col[i].second <= yy[jy])
continue;
if ((col[i].second == yy[iy] || col[i].second == yy[jy]) &&
col[i].first >= xx[ix] && col[i].first <= xx[jx])
continue;
ok = false;
break;
}
}
ok &= rect(xx[ix], yy[iy], xx[jx], yy[jy]);
if (ok) {
cout << "YES\n";
cout << sx + 1 << " " << sy + 1 << " " << fx + 1 << " " << fy + 1
<< endl;
cout << xx[ix] + 1 << " " << yy[iy] + 1 << " " << xx[jx] + 1 << " "
<< yy[jy] + 1 << endl;
exit(0);
}
}
}
}
}
fill(sx, sy, fx, fy, '#');
}
inline void check2(pair<int, int> sa, pair<int, int> fa, pair<int, int> sb,
pair<int, int> fb) {
if (!rect(sa.first, sa.second, fa.first, fa.second)) return;
if (!rect(sb.first, sb.second, fb.first, fb.second)) return;
fill(sa.first, sa.second, fa.first, fa.second, '?');
fill(sb.first, sb.second, fb.first, fb.second, '?');
bool ok = 1;
for (int i = 0; i < (int)(col).size(); ++i) {
if (a[col[i].first][col[i].second] == '#') {
ok = 0;
break;
}
}
if (ok) {
cout << "YES\n";
cout << sa.first + 1 << " " << sa.second + 1 << " " << fa.first + 1 << " "
<< fa.second + 1 << endl;
cout << sb.first + 1 << " " << sb.second + 1 << " " << fb.first + 1 << " "
<< fb.second + 1 << endl;
exit(0);
}
fill(sa.first, sa.second, fa.first, fa.second, '#');
fill(sb.first, sb.second, fb.first, fb.second, '#');
}
int main() {
gets(a[0]);
sscanf(a[0], "%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
gets(a[i]);
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') col.push_back(make_pair(i, j));
}
}
pair<int, int> top = make_pair(-1, -1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '#') {
top = make_pair(i, j);
i = j = 1000000000;
}
}
}
vector<int> xc(0), yc(0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m;) {
int oj = j;
while (j < m && a[i][j] == '#') ++j;
if (j - oj > 4) {
xc.push_back(i);
break;
}
++j;
}
}
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n;) {
int oi = i;
while (i < n && a[i][j] == '#') ++i;
if (i - oi > 4) {
yc.push_back(j);
break;
}
++i;
}
}
if ((int)(xc).size() < 5 && (int)(yc).size() < 5) {
vector<pair<pair<int, int>, pair<int, int> > > vp(0);
sort((xc).begin(), (xc).end());
sort((yc).begin(), (yc).end());
for (int ix = 0; ix < (int)(xc).size(); ++ix)
for (int jx = ix + 1; jx < (int)(xc).size(); ++jx)
if (xc[jx] - xc[ix] > 1)
for (int iy = 0; iy < (int)(yc).size(); ++iy)
for (int jy = iy + 1; jy < (int)(yc).size(); ++jy)
if (yc[jy] - yc[iy] > 1) {
vp.push_back(make_pair(make_pair(xc[ix], yc[iy]),
make_pair(xc[jx], yc[jy])));
}
for (int i = 0; i < (int)(vp).size(); ++i)
for (int j = 0; j < (int)(vp).size(); ++j) {
check2(vp[i].first, vp[i].second, vp[j].first, vp[j].second);
}
}
for (int i = n - 1; i > 0; --i) {
for (int j = m - 1; j > 0; --j) {
if (a[i][j] == '#' && a[i - 1][j] == '#' && a[i][j - 1] == '#') {
check(top.first, top.second, i, j);
}
}
}
cout << "NO\n";
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int a[1000000][2];
int main()
{
int i,j,k,n;
k = 0;
for(i=2;i<1000000;i++){
if(!a[i][0]){
k++;
for(j=2;i*j<1000000;j++){
a[i*j][0] = 1;
}
}
a[i][1] = k;
}
while(cin >> n){
cout << a[n][1] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3F3F3F3F, N = 100008, MOD = 1003;
const double EPS = 1e-6;
long long a[N], l[N], r[N];
int main() {
long long ts, tf, t;
cin >> ts >> tf >> t;
int n;
cin >> n;
bool sym = 0;
long long ans = -1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0) {
l[i] = max(ts, a[i]);
r[i] = l[i] + t;
if (r[i] > tf - t) {
sym = 1;
}
} else {
l[i] = max(a[i], r[i - 1]);
r[i] = l[i] + t;
if (r[i] > tf - t) {
sym = 1;
}
if (l[i] > r[i - 1] && r[i - 1] <= tf - t) {
ans = r[i - 1];
}
}
}
if (ans != -1) {
cout << ans << endl;
} else {
if (n == 0) {
cout << ts << endl;
} else {
if (r[n - 1] <= tf - t) {
cout << r[n - 1] << endl;
} else if (a[0] > ts) {
cout << ts << endl;
} else {
long long mi = abs(l[0] - (a[0] - 1));
ans = a[0] - 1;
for (int i = 1; i < n; i++) {
if (l[i] > tf - t) {
break;
}
if (mi > abs(l[i] - (a[i] - 1))) {
ans = a[i] - 1;
mi = abs(l[i] - (a[i] - 1));
}
}
cout << ans << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (; t--;) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << b << " " << c << " " << c << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int N;
int num[505050];
int S[505050];
void solve() {
int i,j,k,l,r,x,y; string s;
int cur=0;
cin>>N;
FOR(i,N) {
cin>>x>>y;
cur+=x;
cur%=86400;
num[cur]++;
cur+=y;
cur%=86400;
}
FOR(i,86400*3) {
S[i+1]=S[i]+num[i];
num[i+86400]=num[i];
}
int ma=0;
FOR(i,86400*2) ma=max(ma,S[i+3600*3+1]-S[i]);
cout<<ma<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n';
FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
solve(); return 0;
}
| 0 |
#include <iostream>
#include <cstring>
#include <cstdio>
#define MOD 1000000007
using namespace std;
typedef long long ll;
int lst[100005], to[200005], pre[200005], tot;
int dfn[100005], low[100005], st[200005], col[100005], tp, t;
int ecnt[200005], vcnt[200005], bcc;
ll fact[200005], inv[200005];
inline void add_edge(int u, int v)
{
to[tot] = v;
pre[tot] = lst[u];
lst[u] = tot++;
}
inline ll quick_pow(ll a, int n)
{
ll res = 1;
while (n)
{
if (n & 1)
res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
inline int gcd(int x, int y)
{
while (y)
{
int r = x % y;
x = y;
y = r;
}
return x;
}
void tarjan(int u, int fae = -1)
{
dfn[u] = low[u] = t++;
for (int i = lst[u]; ~i; i = pre[i])
{
if (-1 == dfn[to[i]])
{
st[tp++] = i;
tarjan(to[i], i ^ 1);
low[u] = min(low[u], low[to[i]]);
if (low[to[i]] >= dfn[u])
{
bcc++;
do
{
int x = st[--tp];
ecnt[bcc]++;
if (col[to[x]] != bcc)
{
col[to[x]] = bcc;
vcnt[bcc]++;
}
if (col[to[x ^ 1]] != bcc)
{
col[to[x ^ 1]] = bcc;
vcnt[bcc]++;
}
}
while (st[tp] != i);
}
}
else if (i != fae && dfn[to[i]] < dfn[u])
{
st[tp++] = i;
low[u] = min(low[u], dfn[to[i]]);
}
}
}
int main()
{
// freopen("ARC062-F.in", "r", stdin);
memset(lst, -1, sizeof(lst));
fact[0] = inv[0] = 1;
for (int i = 1; i < 505; i++)
{
fact[i] = fact[i - 1] * i % MOD;
inv[i] = quick_pow(fact[i], MOD - 2);
}
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++)
{
int u, v;
scanf("%d%d", &u, &v);
add_edge(--u, --v);
add_edge(v, u);
}
memset(dfn, -1, sizeof(dfn));
for (int i = 0; i < n; i++)
{
if (-1 == dfn[i])
tarjan(i);
}
ll ans = 1;
for (int i = 1; i <= bcc; i++)
{
if (ecnt[i] == 1)
ans = ans * k % MOD;
else if (ecnt[i] == vcnt[i])
{
ll sum = 0;
for (int j = 1; j <= ecnt[i]; j++)
sum = (sum + quick_pow(k, gcd(j, ecnt[i]))) % MOD;
ans = ans * sum % MOD * quick_pow(ecnt[i], MOD - 2) % MOD;
}
else
ans = ans * fact[ecnt[i] + k - 1] % MOD * inv[k - 1] % MOD * inv[ecnt[i]] % MOD;
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e3 + 10;
int n, m, dist[maxn][maxn], sti, stj, pi, pj;
bool mark[maxn][maxn];
char num[maxn][maxn];
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, 1, 0, -1};
bool ok(int i, int j) {
if (i < 0 || j < 0) return false;
if (i >= n || j >= m) return false;
return true;
}
void BFS() {
queue<pair<int, int> > q;
q.push(make_pair(sti, stj));
dist[sti][stj] = 0;
while (!q.empty()) {
pair<int, int> t = q.front();
q.pop();
mark[t.first][t.second] = true;
for (int i = 0; i < 4; i++) {
if (!mark[t.first + di[i]][t.second + dj[i]] &&
ok(t.first + di[i], t.second + dj[i])) {
dist[t.first + di[i]][t.second + dj[i]] = dist[t.first][t.second] + 1;
mark[t.first + di[i]][t.second + dj[i]] = true;
q.push(make_pair(t.first + di[i], t.second + dj[i]));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
dist[i][j] = ((~0) ^ (1 << 31));
cin >> num[i][j];
if (num[i][j] == 'T') {
mark[i][j] = true;
}
if (num[i][j] == 'E') {
sti = i;
stj = j;
}
if (num[i][j] == 'S') {
pi = i;
pj = j;
}
}
BFS();
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (dist[i][j] <= dist[pi][pj] && (i != pi || j != pj) &&
num[i][j] != 'E') {
ans += num[i][j] - '0';
}
}
cout << ans;
}
| 4 |
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
#define int long long int
const int INF = 1001001001001001LL;
const int MOD = 1000000007;
int dp[2][(1 << 18)];
signed main(){
while(1){
int n; cin >> n;
if(!n) break;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
int cur = 0;
int nxt = 1;
for(int i = 0; i < n; i++){
int m, l; cin >> m >> l;
vector<int> s(m);
vector<int> e(m);
for(int j = 0; j < m; j++){
cin >> s[j] >> e[j];
s[j] -= 6;
e[j] -= 6;
}
for(int bit = 0; bit < (1 << 18); bit++){
if(dp[cur][bit] == -1) continue;
//デートしない
dp[nxt][bit] = max(dp[nxt][bit], dp[cur][bit]);
//デートする
bool ok = true;
int nxtbit = 0;
for(int j = 0; j < m; j++){
for(int k = s[j]; k < e[j]; k++) nxtbit = nxtbit | (1 << k);
}
for(int k = 0; k < 18; k++) if(nxtbit & (1 << k) && bit & (1 << k)) ok = false;
nxtbit = bit | nxtbit;
if(ok) dp[nxt][nxtbit] = max(dp[nxt][nxtbit], dp[cur][bit] + l);
}
swap(cur, nxt);
}
int ans = -1;
for(int j = 0; j < (1 << 18); j++) ans = max(ans, dp[cur][j]);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n;
int ans[maxn];
int main() {
cin >> n;
int flag = 1;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
ans[x]++;
ans[y]++;
}
for (int i = 0; i < maxn; i++) {
if (ans[i] == 2) {
flag = 0;
}
}
if (flag) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long min, n, a, b, d, c = 0;
cin >> n;
string s;
vector<long long> v(n);
for (long i = 0; i < n; i++) {
cin >> a;
v[i] = a;
}
sort(v.begin(), v.end());
for (long i = 0; i < n - 1; i++) {
if (i == 0)
min = v[1] - v[0];
else if (v[i + 1] - v[i] <= min) {
min = v[i + 1] - v[i];
}
}
for (long i = 0; i < n - 1; i++) {
if (min == v[i + 1] - v[i]) c++;
}
cout << (long long)min << " " << (long long)c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
const long double E = 1e-9;
unsigned char ccc;
bool _minus = false;
template <typename T>
inline T sqr(T t) {
return (t * t);
}
inline void read(long long &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
inline void read(int &n) {
n = 0;
_minus = false;
while (true) {
ccc = getchar();
if (ccc == ' ' || ccc == '\n') break;
if (ccc == '-') {
_minus = true;
continue;
}
n = n * 10 + ccc - '0';
}
if (_minus) n *= -1;
}
char wwww[19];
int kkkk;
inline void write(long long y) {
long long x = y;
kkkk = 0;
if (x < 0) {
putchar('-');
x *= -1;
}
if (!x)
++kkkk, wwww[kkkk] = '0';
else
while (x) {
++kkkk;
wwww[kkkk] = char(x % 10 + '0');
x /= 10;
}
for (int i = kkkk; i >= 1; --i) putchar(wwww[i]);
}
int n;
const int MAX = 5000;
vector<int> vec[MAX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
srand(time(NULL));
cout.precision(10);
cout << fixed;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
long long a, x, y, m;
cin >> k >> a >> x >> y >> m;
vec[i].push_back(a);
while ((int)vec[i].size() < k) {
a = (a * x + y) % m;
vec[i].push_back(a);
}
reverse(vec[i].begin(), vec[i].end());
}
bool ok = true;
vector<pair<int, int> > ans;
int _ans = -1;
while (ok) {
_ans++;
vector<pair<int, int> > res;
ok = false;
for (int i = 0; i < n; i++) {
if (!vec[i].empty()) {
int val = vec[i].back();
res.push_back(make_pair(val, i + 1));
vec[i].pop_back();
while (!vec[i].empty() && vec[i].back() >= val) {
val = vec[i].back();
vec[i].pop_back();
res.push_back(make_pair(val, i + 1));
}
if (!vec[i].empty()) ok = true;
}
}
sort(res.begin(), res.end());
ans.insert(ans.end(), res.begin(), res.end());
}
cout << _ans << "\n";
for (pair<int, int> a : ans) {
cout << a.first << " " << a.second << "\n";
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a; cin>>a;
cout<<1-a<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 1;
int main() {
char s[N];
scanf("%s", s);
bool esVocal[200] = {};
for (char v : vector<char>{'a', 'e', 'i', 'o', 'u'}) {
esVocal[(int)v] = true;
}
int consecutivas = 0;
char tipo = 0;
for (int i = 0; s[i]; i++) {
char c = s[i];
if (esVocal[(int)c]) {
consecutivas = 0;
tipo = 0;
} else if (!consecutivas) {
tipo = c;
consecutivas = 1;
} else if (tipo == c) {
consecutivas++;
} else if (tipo != c && consecutivas >= 2) {
consecutivas = 1;
tipo = c;
putchar(' ');
} else if (tipo != c && consecutivas < 2) {
tipo = 0;
consecutivas++;
}
putchar(c);
}
putchar('\n');
}
| 1 |
#include <bits/stdc++.h>
const long long LL_INF = (long long)2e18 + 5;
using namespace std;
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long N = 1e6 + 3, mod = 1e9 + 7;
long long dp[N], cost[2][N];
void solve() {
memset(dp, 0x3f3f3f3f, sizeof(dp));
long long n, w1, w2, w3, d;
cin >> n >> w1 >> w2 >> w3 >> d;
vector<long long> v(n);
for (long long i = (long long)(0); i < (long long)(n); i++) {
cin >> v[i];
cost[0][i] = v[i] * w1 + w3;
cost[1][i] = min(w1 * (v[i] + 2), w2 + w1) + 2 * d;
}
for (long long i = (long long)(n - 1); i >= (long long)(0); i--) {
if (i == n - 1) {
dp[i] = min(dp[i], min(cost[0][i], cost[1][i]));
} else {
dp[i] = min(dp[i], min(cost[0][i], cost[1][i]) + d + dp[i + 1]);
if (i == n - 2)
dp[i] = min(dp[i], min(cost[1][i] + cost[0][i + 1],
cost[1][i] + cost[1][i + 1] - d));
}
if (i < n - 2) dp[i] = min(dp[i], cost[1][i] + cost[1][i + 1] + dp[i + 2]);
}
cout << dp[0] << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[500][500], str[500], char_c;
int m[500], ans[500][30], pos[500];
void func(int k) {
for (int i = 0, sz = strlen(str), tam = strlen(s[k]); i < sz - tam + 1; i++) {
int same = 1;
for (int j = 0; j < tam; j++) same = same && str[i + j] == s[k][j];
if (same)
for (int j = 0; j < tam; j++) {
m[i + j] = 1;
ans[i + j][s[k][j] - 'a'] = 1;
}
}
}
char best(int i) {
if (!m[i]) return str[i];
if (!ans[i][char_c - 'a']) return char_c;
int j = 0;
for (; j < 26; j++)
if (!ans[i][j]) return 'a' + j;
if (j == 26) j = 0;
return 'a' + j;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("\n%s", s[i]);
for (int j = 0, sz = strlen(s[i]); j < sz; j++) s[i][j] = tolower(s[i][j]);
}
scanf("\n%s\n%c", str, &char_c);
char_c = tolower(char_c);
for (int i = 0, sz = strlen(str); i < sz; i++) {
pos[i] = isupper(str[i]);
str[i] = tolower(str[i]);
}
for (int i = 0; i < n; i++) func(i);
for (int i = 0, sz = strlen(str); i < sz; i++) {
char new_c = best(i);
if (pos[i]) new_c = toupper(new_c);
printf("%c", new_c);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int a[N], b[N];
int main() {
string ans = "";
int k;
cin >> k;
if (k & 1) ans += '4', k--;
while (ans.size() < 19 && k) {
k -= 2;
ans += '8';
}
if (ans.size() >= 19) return puts("-1"), 0;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
#define var auto
using ll = long long;
const char newl = '\n';
template <typename T1, typename T2> inline void chmin(T1& a, T2 b) {if(a > b) a = b;}
template <typename T1, typename T2> inline void chmax(T1& a, T2 b) {if(a < b) a = b;}
using namespace std;
signed main(){
while(true){
int h, w;
cin >> h >> w;
if (h == 0) return 0;
vector<string> s(h);
for (int i = 0; i < h; i++) cin >> s[i];
vector<pair<int, int>> dirs{
make_pair(1, 1),
make_pair(0, 1),
make_pair(-1, 1),
make_pair(1, 0),
make_pair(-1, 0),
make_pair(1, -1),
make_pair(0, -1),
make_pair(-1, -1),
};
string longest = "";
unordered_set<string> se{};
for (int i = 0; i < h; i++){
for (int j = 0; j < w; j++){
for (auto&& dir : dirs){
int y = i, x = j;
string cur = "";
cur += s[y][x];
do{
y += dir.first;
x += dir.second;
if (y < 0) y += h;
if (x < 0) x += w;
if (h <= y) y -= h;
if (w <= x) x -= w;
if (y == i && x == j) break;
cur += s[y][x];
//cout << cur << endl;
if (!se.insert(cur).second){
if (cur.size() > longest.size() || (cur.size() == longest.size() && cur < longest)) longest = cur;
}
}
while (true);
}
}
}
cout << (longest.size() == 0 ? "0" : longest) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[4096][4096];
void filldp(vector<int> &vec1, vector<int> &vec2) {
for (int i = 0; i < (int)4096; i++)
for (int j = 0; j < (int)4096; j++) dp[i][j] = 86400;
int n = vec1.size();
dp[0][0] = vec1[0] + vec2[0];
for (int i = 0; i < (int)n; i++) dp[i][i + 1] = 0;
for (int i = 1; i < n; i++)
for (int j = i; j >= 0; j--) {
if (dp[i - 1][j] > vec1[i])
dp[i][j] = dp[i - 1][j] + vec2[i];
else
dp[i][j] = vec1[i] + vec2[i];
if (j != 0) dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
}
return;
}
int calc(vector<int> &vec1, vector<int> &vec2, int t, int pos) {
if (pos <= t) return vec1[pos];
return max(vec1[pos] - dp[pos - 1][t], 0);
}
int main() {
int n, t;
cin >> n >> t;
vector<int> vec1(n), vec2(n);
for (int i = 0; i < (int)n; i++) {
cin >> vec1[i] >> vec2[i];
vec1[i]--;
}
vec1.push_back(86400);
vec2.push_back(1);
n++;
int res = 0;
if (n == t)
cout << 86400 << endl;
else {
filldp(vec1, vec2);
for (int i = 0; i < (int)n; i++) {
res = max(res, calc(vec1, vec2, t, i));
}
cout << res << endl;
}
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int A,B,C,D;
cin>>A>>B>>C>>D;
cout<<max(A*B,C*D)<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
string x;
string getans(vector<int> r) {
if ((int)(r.size()) == 0) return "";
string ret = "";
bool init = true;
bool pos = false;
for (int i = 0; i < (int)(x.size()); i++) {
bool p = true;
for (auto v : r)
if (v == i) p = false;
if (p) {
pos = true;
if (x[i] == '0' && init) continue;
init = false;
ret += x[i];
}
}
if (init == true && pos) ret += '0';
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<int> r[2];
cin >> x;
int s[2];
memset(s, 0, sizeof(s));
int a[3];
memset(a, 0, sizeof(a));
int sum = 0;
for (int i = 0; i < (int)(x.size()); i++)
a[(x[i] - '0') % 3]++, sum += x[i] - '0';
sum = sum % 3;
if (sum == 0) {
cout << x << '\n';
return 0;
} else if (sum == 1) {
s[0] = 1;
s[1] = 2;
} else if (sum == 2) {
s[0] = 2;
s[1] = 1;
}
for (int j = 0; j < 2; j++)
for (int i = (int)(x.size()) - 1; i >= 0 && (int)(r[j].size()) < s[j]; i--)
if ((x[i] - '0') % 3 == (j + 1)) r[j].push_back(i);
string a1, a2;
if ((int)(r[0].size()) == s[0]) a1 = getans(r[0]);
if ((int)(r[1].size()) == s[1]) a2 = getans(r[1]);
string ans = a1;
if ((int)(a2.size()) > (int)(a1.size())) ans = a2;
if ((int)(ans.size()) == 0) ans = "-1";
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
string s, d = "hard";
long long int n, a[N];
map<char, int> mskk;
long long int dp[N][32];
long long int calc(int i, int msk) {
if (i == n) {
if (msk == 15)
return 1e18;
else
return 0;
}
long long int &ret = dp[i][msk];
if (ret != -1) return ret;
if (s[i] == 'h') {
if (msk == 0)
return ret = min(calc(i + 1, 1), a[i] + calc(i + 1, msk));
else
return ret = min(calc(i + 1, msk), a[i] + calc(i + 1, msk));
}
for (int j = 1; j < d.size(); j++) {
if (s[i] == d[j]) {
int ww = mskk[d[j]] - 1;
int zz = msk - ww;
if (zz >= 0)
return ret =
min(calc(i + 1, msk | mskk[d[j]]), a[i] + calc(i + 1, msk));
else
return ret = min(calc(i + 1, msk), a[i] + calc(i + 1, msk));
}
}
return ret = calc(i + 1, msk);
}
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int cc = 1;
for (int i = 0; i < d.size(); i++) {
mskk[d[i]] = cc;
cc *= 2;
}
memset(dp, -1, sizeof dp);
cout << calc(0, 0) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string a[105], b[105];
bool vis[105];
int n;
bool cmp(string a, string b) {
if (a.length() != b.length()) {
return a.length() < b.length();
} else {
return a > b;
}
}
int main() {
while (cin >> n) {
string m;
memset(vis, false, sizeof(vis));
for (int i = 0; i < n; i++) {
cin >> m;
a[i] = m;
}
for (int j = 0; j < n; j++) {
cin >> m;
b[j] = m;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (vis[j]) continue;
if (a[i] == b[j]) {
vis[j] = true;
ans++;
break;
}
}
}
cout << n - ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
long long a, b;
cin >> a >> b;
long long sum = a + b;
if (a > b) {
if (sum % 3 || a > 2 * b) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} else if (b > a) {
if (sum % 3 || b > 2 * a) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
} else {
if (sum % 3) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn=3e5+5;
typedef long long ll;
const ll mod=1e9+7;
ll n,cnt[65];
void via(ll x){
int p=0;
while(x){
if(x%2)cnt[p]++;
x>>=1;p++;
}
}
ll C(ll x){
return x*(x-1)/2;
}
int main(){
cin>>n;ll sum=0;
for(ll i=1;i<=n;i++){
ll x;cin>>x;
via(x);
}
ll tmp=0,j=1;
for(ll i=0;i<=62;i++){
tmp+=(cnt[i]*(n-cnt[i])%mod*((j)%mod))%mod;
tmp%=mod;j*=2;
}
cout<<tmp<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char p[30] = {'0', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',
'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
inline long long rd() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * flag;
}
int n, siz[2010], l[2][2010], r[2][2010], f[2][2010][2010], ans[2010], a, x;
vector<int> g[2][2010];
inline void dfs(int op, int x) {
siz[x] = 1;
if (x == 1) siz[x] = 0;
int lmin = l[op][x], rmax = r[op][x];
for (register int i = 0; i < (int)g[op][x].size(); ++i) {
int u = g[op][x][i];
dfs(op, u);
siz[x] += siz[u];
lmin = min(lmin, l[op][u]), rmax = max(rmax, r[op][u]);
}
l[op][x] = lmin, r[op][x] = rmax;
f[op][lmin][rmax] = max(f[op][lmin][rmax], siz[x]);
}
int main() {
n = rd();
for (register int cnt = 0; cnt <= 1; ++cnt) {
a = rd();
for (register int i = 2; i <= a; ++i) {
x = rd();
g[cnt][x].push_back(i);
}
for (register int i = 1; i <= a; ++i) l[cnt][i] = a + 1, r[cnt][i] = 0;
for (register int i = 1; i <= n; ++i) {
x = rd();
l[cnt][x] = i, r[cnt][x] = i;
}
dfs(cnt, 1);
}
for (register int i = 1; i <= n; ++i)
for (register int j = i; j <= n; ++j) {
ans[j] = max(ans[j], ans[i - 1] + max(f[0][i][j], f[1][i][j]));
}
cout << ans[n];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long MOD = 1e9 + 9;
int dcmp(double x) { return (x > eps) - (x < -eps); }
const int N = 2e4 + 10;
int cmpNo;
struct Node {
int p[2], id, x;
bool operator<(const Node &A) const {
if (p[cmpNo] != A.p[cmpNo]) return p[cmpNo] < A.p[cmpNo];
return p[cmpNo ^ 1] < A.p[cmpNo ^ 1];
}
void read() { scanf("%d%d", &p[0], &p[1]); }
} a[N], C;
bool cmp(const Node &A, const Node &B) {
return atan2(1.0 * A.p[1] - C.p[1], 1.0 * A.p[0] - C.p[0]) <
atan2(1.0 * B.p[1] - C.p[1], 1.0 * B.p[0] - C.p[0]);
}
int b[N];
void dfs(int l, int r, int now) {
if (l + 1 == r) {
b[a[l].id] = a[r].id;
b[a[r].id] = a[l].id;
return;
}
int cnt[2]{0}, t = r, mx = r - l + 1;
if (now < 2) {
cmpNo = now, sort(a + l, a + r + 1);
for (int i = l; i <= r; i++) {
cnt[a[i].x]++;
if (i < r && a[i].p[now] == a[i + 1].p[now]) {
continue;
}
if (cnt[0] == cnt[1]) {
int d = abs((i - l + 1) - (r - i));
if (d < mx) {
mx = d;
t = i;
}
}
if (abs((i - l + 1) - (r - i)) > mx) break;
}
dfs(l, t, (now + 1) % 3);
if (t + 1 < r) dfs(t + 1, r, (now + 1) % 3);
} else {
cmpNo = 1, sort(a + l, a + r + 1);
C = a[l];
sort(a + l + 1, a + r + 1, cmp);
for (int i = l; i <= r; i++) {
cnt[a[i].x]++;
if (cnt[0] == cnt[1] && a[i].x != a[l].x) {
int d = abs((i - l + 1) - (r - i));
if (d < mx) {
mx = d;
t = i;
}
}
if (abs((i - l + 1) - (r - i)) > mx) break;
}
b[a[l].id] = a[t].id;
b[a[t].id] = a[l].id;
if (l < t - 1) dfs(l + 1, t - 1, (now + 1) % 3);
if (t + 1 < r) dfs(t + 1, r, (now + 1) % 3);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 2 * n; i++) {
a[i].read();
a[i].id = i;
a[i].x = i / n;
}
dfs(0, 2 * n - 1, 0);
for (int i = 0; i < n; i++) {
printf("%d\n", b[i] - n + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool check(string str, string str2) {
string s = str + str2;
for (int i = 0; i < s.length() / 2; i++) {
if (s[i] == s[s.length() - i - 1]) {
continue;
} else {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
string str;
cin >> str;
long long n = str.length();
string str2 = "", ans;
string pref[n], suf[n];
for (int i = 0; i < n; i++) {
str2 += str[i];
pref[i] = str2;
}
string str3;
for (int i = 0; i < n; i++) {
suf[i] = str.substr(i, n);
}
long long mx = 0, y = 0;
for (int i = 0; i < n; i++) {
if (str[i] == str[n - i - 1]) {
continue;
} else {
y = i;
break;
}
}
string str4 = "";
for (int i = y; i < n - y - 1; i++) {
if (check(str4, str.substr(y, n - y - i))) {
long long x = n - y - i;
if (x > mx) {
mx = x;
ans = str.substr(y, n - y - i);
}
}
}
for (int i = 0; i <= n - (2 * (y)); i++) {
if (check(str4, str.substr(y + i, n - y - y - i))) {
long long x = n - y - y - i;
if (x > mx) {
mx = x;
ans = str.substr(y + i, n - y - y - i);
}
}
}
if (mx != 0) {
mx += 2 * (y + 1);
ans = str.substr(0, y) + ans + str.substr(n - y, y);
}
for (int i = 0; i < n; i++) {
if (check(str4, pref[i])) {
long long x = pref[i].length();
if (x > mx) {
mx = x;
ans = pref[i];
}
}
}
for (int i = 0; i < n; i++) {
if (check(str4, suf[i])) {
long long x = suf[i].length();
if (x > mx) {
mx = x;
ans = suf[i];
}
}
}
if (mx == 0) {
cout << str[0] << " " << '\n';
continue;
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sol = 0;
int n, m;
string s[1 << 17];
vector<int> son[1 << 17];
char t[1 << 20];
int f[1 << 20];
void dfs(int v, int st) {
int u, i, j, k;
for (i = 0; i < (int)son[v].size(); i++) {
u = son[v][i];
k = st;
for (j = 0; j < (int)s[u].size(); j++) {
while (1) {
if (s[u][j] == t[k + 1]) {
k++;
break;
}
if (k == 0) {
break;
}
k = f[k];
}
if (k == m) {
sol++;
k = f[k];
}
}
dfs(u, k);
}
}
int main() {
int i, j, k;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d %s", &k, t);
s[i] = t;
son[k].push_back(i);
}
t[0] = '@';
scanf("%s", t + 1);
m = strlen(t) - 1;
f[0] = f[1] = 0;
for (i = 2; i <= m; i++) {
j = f[i - 1];
while (1) {
if (t[j + 1] == t[i]) {
f[i] = j + 1;
break;
}
if (j == 0) {
f[i] = 0;
break;
}
j = f[j];
}
}
dfs(1, 0);
printf("%d\n", sol);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
int n, c[maxn];
string s[maxn][2];
long long int res[maxn][2];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n; ++i) {
cin >> s[i][0];
s[i][1] = s[i][0];
reverse(s[i][1].begin(), s[i][1].end());
for (int j = 0; j < 2; ++j) {
res[i][j] = 1e18;
for (int k = 0; k < 2; ++k) {
if (s[i][j] >= s[i - 1][k])
res[i][j] = min(res[i][j], res[i - 1][k] + j * c[i]);
}
}
}
long long int ans = min(res[n][0], res[n][1]);
if (ans >= 1e18)
cout << -1;
else
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
bool f[105][205][55][2];
char s[105];
int abs(int x) { return x > 0 ? x : -x; }
int main() {
int n, m, i, j, k, l;
scanf("%s%d", s, &m);
n = strlen(s);
int cnt = 0;
for (i = 0; i < n; i++) {
if (s[i] == 'T') cnt++;
}
if (m >= cnt) {
if (m % 2 == cnt % 2)
printf("%d\n", n);
else
printf("%d\n", n - 1);
return 0;
}
f[0][100][0][0] = true;
for (i = 0; i < n; i++) {
for (j = 0; j < 201; j++) {
for (k = 0; k <= m; k++) {
for (l = 0; l < 2; l++) {
if (!f[i][j][k][l]) continue;
if (s[i] == 'F') {
if (!l) {
f[i + 1][j + 1][k][0] = true;
f[i + 1][j][k + 1][1] = true;
} else {
f[i + 1][j - 1][k][1] = true;
f[i + 1][j][k + 1][0] = true;
}
} else {
if (!l) {
f[i + 1][j][k][1] = true;
f[i + 1][j + 1][k + 1][0] = true;
} else {
f[i + 1][j][k][0] = true;
f[i + 1][j - 1][k + 1][1] = true;
}
}
}
}
}
}
int r = 0;
for (i = 0; i < 201; i++) {
for (k = 0; k < 2; k++) {
if (!f[n][i][m][k]) continue;
if (r < abs(i - 100)) r = abs(i - 100);
}
}
printf("%d\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pfun(string& s) {
int j, n = (int)s.size();
vector<int> p(n, 0);
for (int i = 1; i <= n - 1; i++) {
j = p[i - 1];
while ((j > 0) && (s[i] != s[j])) j = p[j - 1];
if (s[i] == s[j]) p[i] = j + 1;
}
return p;
}
bool used[1000005];
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
string s;
in >> s;
vector<int> p = pfun(s);
int n = (int)s.size();
for (int i = 0; i <= n - 2; i++) {
used[p[i]] = true;
}
int x = p[n - 1];
while (x != 0) {
if (used[x]) break;
x = p[x - 1];
}
if (x == 0)
out << "Just a legend" << '\n';
else {
out << s.substr(0, x) << '\n';
}
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = int(1e5) + 5;
const int oo = int(1e6);
const int MOD = (int)1e9 + 7;
const double EPS = 1e-7;
long long gcd(long long a, long long b) { return (a) ? gcd(b % a, a) : b; }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
using namespace std;
void RUN() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool getBit(long long num, int idx) { return ((num >> idx) & 1); }
long long Fpow(long long x, long long y, long long mod) {
return (!y ? 1
: (((y & 1) ? x : 1) % mod *
Fpow((x % mod) * (x % mod) % mod, y >> 1, mod) % mod) %
mod);
}
map<char, int> mp;
int main() {
RUN();
int ts;
cin >> ts;
while (ts--) {
char ch;
for (int i = 0; i < 26; i++) {
cin >> ch;
mp[ch] = i;
}
string s;
cin >> s;
long long cost = 0;
for (int i = 1; i < (int)(s.size()); i++) {
cost += abs(mp[s[i]] - mp[s[i - 1]]);
}
cout << cost << '\n';
mp.clear();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int offset[] = {1, 0, -1, 0, 1};
long long int n, a, r, m;
long long int sum = 0;
long long int cost(long long int h, vector<long long int> &v) {
long long int req = n * h;
long long int temp = 0;
if (req >= sum) {
temp += a * (req - sum);
for (long long int i = n - 1; i >= 0; i--) {
if (v[i] > h)
temp += (v[i] - h) * m;
else
break;
}
} else {
temp += r * (sum - req);
for (long long int i = 0; i < n; i++) {
if (v[i] < h)
temp += (h - v[i]) * m;
else
break;
}
}
return temp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a >> r >> m;
m = min(m, a + r);
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i], sum += v[i];
sort(v.begin(), v.end());
long long int low = 0, high = 1e9;
while (low < high) {
long long int mid = (low + high) / 2;
if (cost(mid, v) < cost(mid + 1, v))
high = mid;
else
low = mid + 1;
}
cout << cost(low, v) << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.