solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int N;
int n, MOD;
int Ans[7];
long long sx, sy, dx, dy;
long long t;
typedef struct {
int m[100][100];
} Matrix;
void clear(Matrix &a) { memset(a.m, 0, sizeof(a.m)); }
Matrix E;
void danweiE() {
int i, j;
for (i = 0; i < 100; i++)
for (j = 0; j < 100; j++)
if (i == j)
E.m[i][j] = 1;
else
E.m[i][j] = 0;
}
Matrix multi(Matrix a, Matrix b) {
Matrix y;
int i, j, k;
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
long long c = 0;
for (k = 0; k < N; k++) {
c += (long long)a.m[i][k] * b.m[k][j];
}
c %= n;
y.m[i][j] = c;
}
}
return y;
}
Matrix matrix_mod(Matrix a, long long k) {
danweiE();
Matrix ans = E, p = a;
while (k) {
if (k & 1) {
ans = multi(ans, p);
k--;
}
k >>= 1;
p = multi(p, p);
}
return ans;
}
int main() {
Matrix a, ans;
int i, j;
N = 6;
cin >> n >> sx >> sy >> dx >> dy >> t;
dx = (dx % n + n) % n;
dy = (dy % n + n) % n;
MOD = n;
for (i = 0; i < 6; i++)
for (j = 0; j < 6; j++) a.m[i][j] = 1;
a.m[0][3] = a.m[0][5] = a.m[1][2] = a.m[1][5] = a.m[2][3] = a.m[2][5] =
a.m[3][2] = a.m[3][5] = a.m[4][0] = a.m[4][1] = a.m[4][2] = a.m[4][3] =
a.m[5][0] = a.m[5][1] = a.m[5][2] = a.m[5][3] = a.m[5][4] = 0;
a.m[0][0] = a.m[1][1] = 2;
ans = matrix_mod(a, t);
memset(Ans, 0, sizeof(Ans));
long long st[6];
st[0] = sx;
st[1] = sy;
st[2] = dx;
st[3] = dy;
st[4] = 0;
st[5] = 1;
for (i = 0; i < 2; i++) {
for (j = 0; j < 6; j++)
Ans[i] = ((long long)Ans[i] + (long long)ans.m[i][j] * st[j] % n) % n;
}
if (!Ans[0]) Ans[0] = n;
if (!Ans[1]) Ans[1] = n;
cout << Ans[0] << " " << Ans[1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool task(string w, string l) {
string ans = "?";
string comp;
if (w == "paper")
comp = "rock";
else if (w == "rock")
comp = "scissors";
else
comp = "paper";
if (l == comp) return true;
return false;
}
int main() {
string a, b, c;
cin >> a >> b >> c;
string ans = "?";
if (a == b && a == c)
cout << ans;
else {
if (a != b && a != c && b != c)
cout << "?";
else {
if (a == b) {
if (task(c, a)) ans = "S";
} else {
if (a == c) {
if (task(b, a)) ans = "M";
} else {
if (task(a, c)) ans = "F";
}
}
cout << ans;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 9.2e18;
const int maxn = 2e5 + 70;
const int INF = 2.1e9;
const int maxm = 1e6 + 70;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k;
int a[maxn];
int main() {
while (cin >> n) {
string s;
cin >> s;
sort((s).begin(), (s).end());
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
const int N = 1650;
int a[N][N], id[N][N], sm[N][N], b[N][N];
int ret[N];
int n, m, tot;
void dfs(int x, int y, int d) {
id[x][y] = d;
for (int j = 0; j < 4; j++)
if ((0 < (x + dx[j]) && (x + dx[j]) <= n && 0 < (y + dy[j]) &&
(y + dy[j]) <= m) &&
a[x + dx[j]][y + dy[j]] && !id[x + dx[j]][y + dy[j]])
dfs(x + dx[j], y + dy[j], d);
}
void dfs2(int x, int y) {
b[x][y] = 0;
for (int j = 0; j < 4; j++)
if ((0 < (x + dx[j]) && (x + dx[j]) <= n && 0 < (y + dy[j]) &&
(y + dy[j]) <= m) &&
b[x + dx[j]][y + dy[j]])
dfs2(x + dx[j], y + dy[j]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &a[i + 10][j + 10]);
n += 20;
m += 20;
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) sm[i][j] = sm[i][j - 1] + a[i][j];
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) sm[i][j] = sm[i - 1][j] + sm[i][j];
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++)
b[i][j] = a[i][j] && (sm[i + 4][j + 4] - sm[i - 5][j + 4] -
sm[i + 4][j - 5] + sm[i - 5][j - 5] <=
25);
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++)
if (a[i][j] && !id[i][j]) dfs(i, j, ++tot);
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++)
if (b[i][j]) {
dfs2(i, j);
ret[id[i][j]]++;
}
sort(ret + 1, ret + tot + 1);
printf("%d\n", tot);
for (int i = 1; i < tot + 1; i++) printf("%d ", ret[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int N;
long long X[MAXN], Y[MAXN];
bool B[MAXN];
bool garis(int P, int Q, int R) {
if (P == R) {
return 1;
}
if (Q == R) {
return 1;
}
long long xa, ya, xb, yb;
xa = X[Q] - X[P];
ya = Y[Q] - Y[P];
xb = X[R] - X[Q];
yb = Y[R] - Y[Q];
if (xa * yb == xb * ya) {
return 1;
}
return 0;
}
void buat(int P, int Q) {
int i;
for (i = 1; i <= N; i++) {
B[i] = garis(P, Q, i);
}
P = -1;
Q = -1;
for (i = 1; i <= N; i++) {
if (!B[i]) {
if (P == -1) {
P = i;
} else if (Q == -1) {
Q = i;
} else if (!garis(P, Q, i)) {
return;
}
}
}
cout << "YES\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
if (N < 5) {
cout << "YES\n";
return 0;
}
int i;
for (i = 1; i <= N; i++) {
cin >> X[i] >> Y[i];
}
buat(1, 2);
buat(1, 3);
buat(2, 3);
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 1e5;
const int INF = 0x7fffffff;
const int mod = 1e9 + 7;
const double eps = 1e-7;
const double Pi = acos(-1.0);
inline int read_int() {
char c;
int ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline long long read_ll() {
char c;
long long ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
long long res, arr[maxn + 5];
int n;
int main() {
n = read_int();
for (int i = 1; i <= n; ++i) arr[i] = read_int();
for (int i = 1; i <= n - 1; ++i) {
if (arr[i] <= arr[i + 1])
res += arr[i] * (arr[i + 1] - arr[i]);
else
res += (n - arr[i] + 1) * (arr[i] - arr[i + 1]);
}
res += arr[n] * (n - arr[n] + 1);
cout << res << endl;
return 0;
}
| 5 |
#include <cstdio>
long long a [100010];
int main (){
int n;
scanf("%d",&n);
for(int i=0;i<n;i++) scanf("%lld",&a[i]);
int zero =0;
for(int i=0;i<n;i++)if(a[i]==0) zero ++;
if(zero >0){
printf("0\n");
return 0;
}
long long prod =1;
for(int i=0;i<n;i++){
if(a[i ] <=1000000000000000000/ prod ){
prod *=a[i];
}else{
printf("-1\n");
return 0;
}
}
printf("%lld\n",prod );
}
| 0 |
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
vector<int> comp;
vector<vector<int> > G;
void dfs(int pos, int pre) {
comp.push_back(pos);
for (int i : G[pos]) {
if (i == pre) continue;
dfs(i, pos);
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, M;
cin >> N >> M;
G.resize(N);
vector<int> v(N);
for (int i = 0; i < N; ++i) cin >> v[i];
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
vector<bool> vis(N);
vector<int> all; int C = 0;
long long ans = 0;
for (int i = 0; i < N; ++i) {
if (vis[i]) continue;
comp.clear();
dfs(i, -1);
int opt = 1 << 30;
for (int j : comp) {
vis[j] = true;
opt = min(opt, v[j]);
}
ans += opt;
++C;
for (int j : comp) {
if (v[j] == opt) {
opt = -1;
}
else {
all.push_back(v[j]);
}
}
}
sort(all.begin(), all.end());
if (C == 1) cout << 0 << endl;
else if (all.size() < C - 2) cout << "Impossible" << endl;
else {
for (int i = 0; i < C - 2; ++i) ans += all[i];
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char maps[15][15];
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a > b ? b : a; }
int abs(int a) {
if (a < 0)
return 0 - a;
else
return a;
}
int main(void) {
for (int i = 0; i < 10; i++) scanf("%s", maps[i]);
int tag = 0;
int count1 = 0;
int count2 = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (maps[i][j] == 'O') continue;
for (int k = 0; k < 5; k++) {
if (i + 5 > 10) break;
if (maps[i + k][j] == 'X')
count1++;
else if (maps[i + k][j] == '.')
count2++;
}
if (count1 == 4 && count2 == 1) tag = 1;
count1 = 0;
count2 = 0;
for (int k = 0; k < 5; k++) {
if (j + 5 > 10) break;
if (maps[i][j + k] == 'X')
count1++;
else if (maps[i][j + k] == '.')
count2++;
}
if (count1 == 4 && count2 == 1) tag = 1;
count1 = 0;
count2 = 0;
for (int k = 0; k < 5; k++) {
if (i + 5 > 10 || j + 5 > 10) break;
if (maps[i + k][j + k] == 'X')
count1++;
else if (maps[i + k][j + k] == '.')
count2++;
}
if (count1 == 4 && count2 == 1) tag = 1;
count1 = 0;
count2 = 0;
for (int k = 0; k < 5; k++) {
if (i + 5 > 10 || j - 4 < 0) break;
if (maps[i + k][j - k] == 'X')
count1++;
else if (maps[i + k][j - k] == '.')
count2++;
}
if (count1 == 4 && count2 == 1) tag = 1;
count1 = 0;
count2 = 0;
}
}
if (tag)
printf("YES\n");
else
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mat[104][104], n, m;
bool col[103];
void D1(int u) {
int i;
for (i = 1; i <= n; i++)
if (mat[u][i] != -1 && col[i]) {
m += mat[u][i];
col[i] = false;
D1(i);
}
}
void D2(int u) {
int i;
for (i = n; i >= 1; i--)
if (mat[u][i] != -1 && col[i]) {
m += mat[u][i];
col[i] = false;
D2(i);
}
}
int main() {
int ks = 1, tt, i, j, k, mx, cu, u, v, c;
while (cin >> n) {
mx = 10000000;
memset(mat, -1, sizeof(mat));
for (i = 0; i < n; i++) {
cin >> u >> v >> c;
mat[u][v] = 0;
mat[v][u] = c;
}
m = 0;
memset(col, true, sizeof(col));
col[1] = false;
D1(1);
for (i = n; i >= 1; i--)
if (mat[1][i] != -1) {
m += mat[i][1];
break;
}
if (mx > m) mx = m;
m = 0;
memset(col, true, sizeof(col));
col[1] = false;
D2(1);
for (i = 1; i <= n; i++)
if (mat[1][i] != -1) {
m += mat[i][1];
break;
}
if (mx > m) mx = m;
cout << mx << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n == 0)
cout << 1;
else if (n == 1)
cout << 5;
else
cout << 25;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define range(a) a.begin(), a.end()
#define endl "\n"
#define YES() cout << "YES" << endl
#define NO() cout << "NO" << endl
#define MP make_pair
using P = pair<int, int>;
const long long INF = 1LL<<60;
void chmin(long long &a, long long b) { if (a > b) a = b; }
void chmax(long long &a, long long b) { if (a < b) a = b; }
template<typename T>
T gcd(T a, T b){
if (a%b == 0){
return b;
}else{
return gcd(b, a % b);
}
}
template<typename T>
T lcm(T a, T b){
return a * b / gcd(a, b);
}
void solve(){
int N;
cin >> N;
vector<int> A(N);
FOR(i,0,N){
cin >> A[i];
}
vector<int> I, J, X, Y;
FOR(i,0,N-1){
if(gcd(A[i], A[i+1]) != 1){
int m = min(A[i], A[i + 1]);
if(m == A[i]){
A[i + 1] = m + 1;
}else{
if(i == 0){
A[i] = A[i + 1] + 1;
}else{
//A[i] = lcm(A[i - 1], A[i + 1]) + 1;
int u = m + 1;
while(1){
if(gcd(A[i-1], u) == 1 && gcd(A[i+1], u) == 1){
A[i] = u;
break;
}else{
++u;
}
}
}
}
I.push_back(i + 1);
J.push_back(i + 2);
X.push_back(A[i]);
Y.push_back(A[i + 1]);
}
}
/*
for(auto x: A){
cout << x << " ";
}
cout << endl << endl;
*/
int k = I.size();
cout << k << endl;
FOR(i,0,k){
cout << I[i] << " " << J[i] << " " << X[i] << " " << Y[i] << endl;
}
return;
}
int main(void){
ios::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while(T--){
solve();
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long x,r,d;
cin>>r>>d>>x;
for(int i=0;i<10;i++)
{
x=x*r-d;
cout<<x<<endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
#include<vector>
using namespace std;
int t;
vector<vector<int>>G;
vector<int>f,deep;
int ans=0;
void init(int n)
{
f.assign(n+5,n+5);
deep.assign(n+5,0);
for(auto i:G){ i.clear();}
G.clear();
G.resize(n+5);
ans=0;
}
int dfs(int x,int fa)
{
int flag=0;
for(int v:G[x])
{
if(v==fa) continue;
flag=1;
deep[v]=deep[x]+1;
f[x]=min(f[x],dfs(v,x));
}
if(flag==0) return f[x]=deep[x];
int now=0;
if(x!=1)
for(int v:G[x])
{
if(v==fa) continue;
if(f[x]==f[v] && now==0) now=1;
else ans=max(ans,f[v]-deep[x]+1);
}
else
{
for(int v:G[x]) if(v!=fa) f[x]=max(f[x],f[v]);
for(int v:G[x])
{
if(v==fa) continue;
if(f[x]==f[v] && now==0) now=1;
else ans=max(ans,f[v]-deep[x]+1);
}
ans=max(ans,f[x]);
}
return f[x];
}
int main()
{
cin>>t;
while(t--)
{
int n;
cin>>n;
init(n);
int x,y;
for(int i=1;i<n;i++)
{
cin>>x>>y;
G[x].push_back(y);
G[y].push_back(x);
}
dfs(1,-1);
cout<<ans<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
const int maxn = 1e5 + 10;
char s[maxn];
int check() {
int n = strlen(s);
char now = 'a';
for (int i = 0; i < n; i++) {
if (s[i] <= now) s[i] = now++;
if (now > 'z') return 1;
}
return 0;
}
int main() {
scanf("%s", s);
if (check())
printf("%s\n", s);
else
printf("-1\n");
return 0;
}
| 3 |
#include <cstdio>
int main() {
int A, B;
scanf("%d %d", &A, &B);
printf("%d\n", (A-1)*(B-1));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> A_ans, B_ans;
int a, b;
vector<int> A, B;
bool can(int x) {
long long total = x * 1LL * (x + 1) / 2;
int s = 0;
int k = 0;
while (s + (k + 1) <= a && (k + 1) <= x) {
k++;
s += k;
}
int t = a - s;
int taken = -1;
for (int i = 1; i <= k; i++) {
if (i + t > k && i + t <= x) {
taken = i;
s = a;
break;
}
}
total -= s;
if (total <= (long long)b) {
A.clear();
B.clear();
for (int i = 1; i <= x; i++) {
if ((i <= k && i != taken) || (taken != -1 && i == taken + t))
A.push_back(i);
else
B.push_back(i);
}
}
return (total <= (long long)b);
}
int main() {
ignore = scanf("%d %d", &a, &b);
int L = 0, R = 100000;
while (L <= R) {
int M = (L + R) / 2;
if (can(M)) {
L = M + 1;
A_ans = A;
B_ans = B;
} else {
R = M - 1;
}
}
printf("%d\n", (int)A_ans.size());
for (int x : A_ans) printf("%d ", x);
printf("\n");
printf("%d\n", (int)B_ans.size());
for (int x : B_ans) printf("%d ", x);
}
| 1 |
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <sstream>
#include <typeinfo>
#include <queue>
#include <stack>
#include <tuple>
using namespace std;
typedef long long ll;
const int MAX_V = 110;
const int INT_INF = 1<<30;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
struct edge {
int cap, cost;
};
int G[MAX_V][MAX_V];
int h[MAX_V*2+2], dist[MAX_V*2+2];
int prevv[MAX_V*2+2];
bool used[MAX_V*2+2];
bool flow[MAX_V][MAX_V] = {};
int bit_matching_cost(int l, int r) {
int min_f = 0;
for (int i = 0; i < l; i++) {
for (int j = 0; j < r; j++) {
min_f = min(min_f, G[i][j]);
}
}
for (int i = 0; i < l; i++) {
for (int j = 0; j < r; j++) {
G[i][j] -= min_f;
}
}
for (int i = 0; i < l; i++) {
G[i][r] = 0;
flow[i][r] = true;
}
for (int i = 0; i < r; i++) {
G[l][i] = 0;
flow[l][i] = true;
}
G[l][r] = INT_INF;
flow[l][r] = false;
int res = 0;
fill_n(h, l+r+2, 0);
while (true) {
fill_n(dist, l+r+2, INT_INF);
dist[l+r+1] = 0;
fill_n(used, l+r+2, false);
while (true) {
int v = -1;
int dist2 = 0;
int flag;
for (int i = 0; i < l+1; i++) {
if (!used[i] && (v == -1 || dist[i] < dist2)){
v = i;
dist2 = dist[i];
flag = true;
}
}
for (int i = 0; i < r+1; i++) {
if (!used[i+l+1] && (v == -1 || dist[i+l+1] < dist2)){
v = i;
dist2 = dist[i+l+1];
flag = false;
}
}
if (v == -1) break;
if (flag) {
used[v] = true;
for (int i = 0; i < r+1; i++) {
if (!flow[v][i] && dist[i+l+1] > dist[v] + G[v][i] + h[v] - h[i+l+1]) {
dist[i+l+1] = dist[v] + G[v][i] + h[v] - h[i+l+1];
prevv[i+l+1] = v;
}
}
} else {
used[v+l+1] = true;
for (int i = 0; i < l+1; i++) {
if (flow[i][v] && dist[i] > dist[v+l+1] - G[i][v] + h[v+l+1] - h[i]) {
dist[i] = dist[v+l+1] - G[i][v] + h[v+l+1] - h[i];
prevv[i] = v;
}
}
}
}
if (dist[l] >= INT_INF) {
break;
}
for (int v = 0; v < l+r+2; v++) {
h[v] += dist[v];
}
res += h[l];
res += min_f;
bool flag = true;
for (int v = l; !(v == r && !flag) ; v = (flag) ? prevv[v] : prevv[v+l+1], flag = !flag) {
if (flag) {
flow[v][prevv[v]] = false;
} else {
flow[prevv[v+l+1]][v] = true;
}
}
}
return res;
}
int cost[MAX_V][MAX_V];
const int MAX_N = 105;
int N;
int W[MAX_N][MAX_N], E[MAX_N][MAX_N];
bool F[MAX_N][MAX_N], F2[MAX_N][MAX_N];
int main(int argc, char *argv[]) {
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
scanf("%d", &(W[i][j]));
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
scanf("%d", &(E[i][j]));
}
}
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < N; j++) {
F[i][j] = (s[j] == 'o');
}
}
int f = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (F[i][j]) {
G[i][j] = -E[i][j];
f += E[i][j];
} else {
G[i][j] = W[i][j];
}
}
}
f += bit_matching_cost(N, N);
int c = 0;
vector<T> q;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (F[i][j] != flow[i][j]) {
c++;
q.push_back(T(i, j, F[i][j]));
}
}
}
printf("%d\n%d\n", f, c);
for (T t: q) {
printf("%d %d %s\n", get<0>(t)+1, get<1>(t)+1, get<2>(t) ? "erase" : "write");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000")
int L, f, b, q;
int mm[100005 * 4], ll[100005 * 4], rr[100005 * 4], num[100005 * 4],
setv[100005 * 4];
int sr[100005 * 4], st[100005], len[100005];
void build(int o, int l, int r) {
mm[o] = ll[o] = rr[o] = num[o] = r - l;
sr[o] = l;
if (l == r - 1) return;
int m = (l + r) / 2;
build(o * 2, l, m);
build(o * 2 + 1, m, r);
}
void down(int o, int l, int r) {
if (setv[o] != -1) {
int m = (l + r) / 2;
setv[o * 2] = setv[o * 2 + 1] = setv[o];
if (setv[o]) {
ll[o * 2] = rr[o * 2] = num[o * 2] = mm[o * 2];
sr[o * 2] = l;
ll[o * 2 + 1] = rr[o * 2 + 1] = num[o * 2 + 1] = mm[o * 2 + 1];
sr[o * 2 + 1] = m;
} else {
ll[o * 2] = rr[o * 2] = num[o * 2] = ll[o * 2 + 1] = rr[o * 2 + 1] =
num[o * 2 + 1] = 0;
sr[o * 2] = m;
sr[o * 2 + 1] = r;
}
setv[o] = -1;
}
}
void up(int o, int l, int r) {
int m = (l + r) / 2;
num[o] = max(num[o * 2], num[o * 2 + 1]);
num[o] = max(num[o], rr[o * 2] + ll[o * 2 + 1]);
if (ll[o * 2] == mm[o * 2])
ll[o] = ll[o * 2] + ll[o * 2 + 1];
else
ll[o] = ll[o * 2];
if (rr[o * 2 + 1] == mm[o * 2 + 1])
rr[o] = rr[o * 2] + rr[o * 2 + 1], sr[o] = sr[o * 2];
else
rr[o] = rr[o * 2 + 1], sr[o] = sr[o * 2 + 1];
}
int query(int len, int o, int l, int r) {
if (num[o] < len) return -1;
if (ll[o] >= len) return l;
int m = (l + r) / 2;
if (num[o * 2] >= len) return query(len, o * 2, l, m);
if (rr[o * 2] + ll[o * 2 + 1] >= len) return sr[o * 2];
if (num[o * 2 + 1] >= len) return query(len, o * 2 + 1, m, r);
return -1;
}
int query(int len) {
if (ll[1] >= b + len) return 0;
if (ll[1] == mm[1] && ll[1] >= len) return 0;
int q1 = query(len + b + f, 1, 0, L);
if (q1 != -1) return q1 + f;
if (rr[1] >= len + f) return sr[1] + f;
return -1;
}
void update(int L, int R, int v, int o, int l, int r) {
if (L <= l && r <= R) {
setv[o] = v;
if (v)
ll[o] = rr[o] = num[o] = mm[o], sr[o] = l;
else
ll[o] = rr[o] = num[o] = 0, sr[o] = r;
return;
}
if (l >= R || L >= r) return;
int m = (l + r) / 2;
if (L <= m) update(L, R, v, o * 2, l, m);
if (m < R) update(L, R, v, o * 2 + 1, m, r);
up(o, l, r);
}
int main() {
scanf("%d%d%d%d", &L, &f, &b, &q);
{
int n = 0, x, y;
build(1, 0, L);
memset(setv, -1, sizeof(setv));
for (int i = 1; i <= q; i++) {
n++;
scanf("%d%d", &x, &y);
if (x == 1) {
int qq = query(y);
if (qq == -1)
printf("-1\n");
else {
st[n] = qq;
len[n] = y;
printf("%d\n", qq);
update(qq, qq + y, 0, 1, 0, L);
}
} else {
int qq = st[y];
int l = len[y];
update(qq, qq + l, 1, 1, 0, L);
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, q, l[55], r[55];
struct edge {
int u, v, cap, flow, cost;
edge() {}
edge(int u, int v, int c, int f, int cost)
: u(u), v(v), cap(c), flow(f), cost(cost) {}
};
vector<edge> edges;
vector<int> e[100010];
int vis[100010], dis[100010], pre[100010], a[100010];
void add_edge(int u, int v, int c, int cost) {
edges.push_back(edge(u, v, c, 0, cost));
edges.push_back(edge(v, u, 0, 0, -cost));
int cnt = edges.size();
e[u].push_back(cnt - 2);
e[v].push_back(cnt - 1);
}
bool spfa(int s, int t, int& flow, int& cost) {
memset(dis, 0x3f3f3f3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
queue<int> que;
que.push(s);
dis[s] = 0;
vis[s] = 1;
pre[s] = 0;
a[s] = 0x3f3f3f3f;
while (!que.empty()) {
int now = que.front();
que.pop();
for (int i = 0; i < e[now].size(); i++) {
edge& ee = edges[e[now][i]];
if (ee.cap > ee.flow && dis[ee.v] > dis[now] + ee.cost) {
dis[ee.v] = dis[now] + ee.cost;
pre[ee.v] = e[now][i];
a[ee.v] = min(a[now], ee.cap - ee.flow);
if (!vis[ee.v]) {
que.push(ee.v);
vis[ee.v] = 1;
}
}
}
vis[now] = 0;
}
if (dis[t] == 0x3f3f3f3f) return false;
flow += a[t];
cost += (dis[t] * a[t]);
int u = t;
while (u != s) {
edges[pre[u]].flow += a[t];
edges[pre[u] ^ 1].flow -= a[t];
u = edges[pre[u]].u;
}
return true;
}
pair<int, int> MCMF(int s, int t) {
int flow = 0, cost = 0;
while (spfa(s, t, flow, cost))
;
return make_pair(flow, cost);
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) l[i] = 1, r[i] = n;
for (int i = 1; i <= q; i++) {
int op, L, R, v;
scanf("%d %d %d %d", &op, &L, &R, &v);
if (op == 1)
for (int j = L; j <= R; j++) l[j] = max(l[j], v);
else
for (int j = L; j <= R; j++) r[j] = min(r[j], v);
}
int S = 0, T = 2 * n + 1;
for (int i = 1; i <= n; i++) {
add_edge(S, i, 1, 0);
for (int j = l[i]; j <= r[i]; j++) add_edge(i, n + j, 1, 0);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
add_edge(i + n, T, 1, j * j - (j - 1) * (j - 1));
pair<int, int> ans = MCMF(S, T);
if (ans.first != n)
puts("-1");
else
printf("%d\n", ans.second);
}
| 6 |
#include <cstdio>
#include <iostream>
using namespace std;
int main(){
int y,m,d,x;
while (cin >> y >> m >> d){
x = y * 10000 + m * 100 + d;
if (x < 18680908) cout << "pre-meiji\n";
else if (x < 19120730) printf("meiji %d %d %d\n", y - 1867, m,d);
else if (x < 19261225) printf("taisho %d %d %d\n", y - 1911, m, d);
else if (x < 19890108) printf("showa %d %d %d\n", y - 1925, m, d);
else printf("heisei %d %d %d\n", y - 1988, m, d);
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define l(a) int((a).size())
#define ll long long
#define f(i,n) for(i=0;i<n;i++)
#define vii vector<pair<int,int> v
#define vll vector<pair<long long,long long>v
#define mod 998244353
#define pb push_back
#define fi first
#define se second
const int mx=100007;
vector<int>v;
int a[10];
long long power(long long a, long long b)
{
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int modInverse(int a, int prime)
{
a = a % prime;
for (int x=1; x<prime; x++)
if ((a*x) % prime == 1)
return x;
return -1;
}
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
void SieveOfEratosthenes(int n,vector<int> &v)
{
bool prime[n+1];
memset(prime,true,sizeof(prime));
for(int i=2;i*i<=n;i++)
{
if(prime[i]==true)
{
for(int j=i*i;j<=n;j+=i)
prime[j]=false;
}
}
for(int i=2;i<=n;i++)
{
if(prime[i])
{
v.push_back(i);
}
}
}
int get(int n)
{
int sum = 0;
while (n != 0)
{
sum = sum + n % 10;
n /= 10;
}
return sum;
}
int reverse( int n )
{
int rev = 0;
while( n )
{
int rem = n % 10;
rev = rev * 10 + rem;
n /= 10;
}
return rev;
}
long long int subset_sum( vector< long long int > a, long long int n )
{
long long int s1 = 0;
for( long long int i = 0; i < n; i++ )
s1 += a[i];
long long int s = (s1);
bool dp[n+1][s+1];
for( long long int i = 0; i <= n; i++ )
dp[i][0] = true;
for( long long int i = 1; i <= s; i++ )
dp[0][i] = false;
for( long long int i = 1; i <= n; i++ )
{
for( long long int j = 1; j <= s; j++ )
{
dp[i][j] = dp[i-1][j];
if( a[i-1] <= j )
dp[i][j] |= dp[i-1][j-a[i-1]];
}
}
long long int m = INT_MAX;
for( int i = s/2; i >= 0; i-- )
{
if( dp[n][i] == true )
{
m = s - 2*i;
break;
}
}
return m;
}
int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
bool prime( int n )
{
if( n < 2 )
return false;
if( n < 4 )
return true;
if( n % 2 == 0 || n % 3 == 0 )
return false;
for( int i = 5; i*i <= n; i += 6 )
if( n % i == 0 || n % ( i + 2 ) == 0 )
return false;
return true;
}
int find_next_prime( int n )
{
while( 1 )
{
if( prime( n ) )
return n;
n++;
}
}
bool isPowerOfTwo(int n)
{
if (n == 0)
return 0;
while (n != 1)
{
if (n%2 != 0)
return 0;
n = n/2;
}
return 1;
}
int solve( int n, int k )
{
int dp[k+1][n+1];
for( int i = 0; i <= k; i++ )
dp[i][0] = 0;
for( int i = 0; i <= n; i++ )
dp[0][i] = 1;
for( int i = 1; i <= k; i++ )
{
for( int j = 1; j <= n; j++ )
{
dp[i][j] = ( dp[i][j-1] + dp[i-1][j-1] ) % 1000000007;
}
}
return dp[k][n];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while( t-- )
{
int n, k;
cin >> n >> k;
int a[n];
for( int i = 0; i < n; i++ )
cin >> a[i];
map< int, int > mp;
for( int i = 0; i < n; i++ )
mp[a[i]]++;
sort( a, a+n );
reverse( a, a+n );
int x = a[k-1];
int count = 0;
for( int i = 0; i < k; i++ )
{
if( a[i] == x )
count++;
}
cout << solve( mp[x], count ) % 1000000007 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
using namespace std;
int q, mod, n;
char s[maxn];
int md[maxn];
void exgcd(long long a, long long b, long long& d, long long& x, long long& y) {
if (!b) {
d = a;
x = 1;
y = 0;
} else {
exgcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
long long inv(long long a, long long p) {
long long d, x, y;
exgcd(a, p, d, x, y);
return d == 1 ? (x + p) % p : -1;
}
void solve() {
cin >> s;
cin >> mod;
n = (int)strlen(s);
int xxx = inv(10, mod);
int ans = 0;
md[0] = 1;
for (int i = 1; i <= n; i++) md[i] = md[i - 1] * 10 % mod;
int dd = 1;
for (int i = n - 1; i >= 0; i--) {
ans = ans + (s[i] - '0') * dd;
ans %= mod;
dd = dd * 10 % mod;
}
int last = ans;
for (int i = 0; i < n; i++) {
int tp = last;
tp = (tp - (s[i] - '0') * md[n - 1]) % mod;
tp = tp * 10 % mod;
tp += s[i] - '0';
tp %= mod;
if (tp < 0) tp += mod;
int c = i + 1;
if (c == n) c = 0;
if (s[c] != '0') ans = min(ans, tp);
last = tp;
}
cout << ans;
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, g, b, k, ans = 0, x;
cin >> n >> g >> b;
k = n / 2 + n % 2;
long long r = k / g;
ans = (r) * (g + b);
if (k % g == 0)
ans -= b;
else
ans += k % g;
cout << max(ans, n) << endl;
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string ara[110], s;
int n;
int main() {
int i, j;
cin >> s >> n;
for (i = 0; i < n; i++) cin >> ara[i];
sort(ara, ara + n);
for (i = 0; i < n; i++) {
if (s == ara[i]) {
cout << s << endl;
return 0;
}
if (s.size() <= ara[i].size()) {
int len = (int)s.size();
bool f = 1;
for (j = 0; j < len; j++) {
if (s[j] != ara[i][j]) {
f = 0;
break;
}
}
if (f) {
cout << ara[i] << endl;
return 0;
}
}
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
int main() {
long long n, x, y;
cin >> n;
priority_queue<pair<long long, long long> > q;
while (n--) {
cin >> x;
y = x;
long long pw = 0;
while (y % 3 == 0) pw++, y /= 3;
q.push({pw, -1 * x});
}
while (!q.empty()) {
cout << -1 * q.top().second << " ";
q.pop();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
int a, x;
cin >> a;
n--;
vector<int> v;
v.push_back(a);
while (n--) {
cin >> x;
v.push_back(x);
a = gcd(a, x);
}
for (int i = 0; i < (int)v.size(); ++i)
if (a % v[i] == 0) {
cout << v[i] << '\n';
return 0;
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define rep1(i, n) for(int i = 1; i < (n); ++i)
using namespace std;
typedef long long ll;
int main(){
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> x(n), y(n), p(n);
rep(i, n) cin >> x[i] >> y[i] >> p[i];
const ll INF = 1ll << 60;
vector<ll> res(n+1, INF);
vector<int> xs, ys, no;
for(ll i = 0; i < pow(3, n); ++i){
xs.clear();
ys.clear();
no.clear();
ll dig = i;
rep(j, n){
if(dig % 3 == 0) no.push_back(j);
if(dig % 3 == 1) xs.push_back(j);
if(dig % 3 == 2) ys.push_back(j);
dig /= 3;
}
ll cost = 0;
for(int j: no){
ll dist = min(abs(x[j]), abs(y[j]));
for(int k: xs) dist = min(dist, abs(x[k]-x[j]));
for(int k: ys) dist = min(dist, abs(y[k]-y[j]));
cost += dist * p[j];
}
int cnt = xs.size() + ys.size();
res[cnt] = min(res[cnt], cost);
}
rep(i, n+1) cout << res[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[10050];
int num[305];
int a[10050];
int main() {
int n, t, mnum = 0;
cin >> n >> t;
memset(num, 0, sizeof num);
for (int i = 0; i < n; i++) {
cin >> a[i];
num[a[i]]++;
mnum = max(mnum, num[a[i]]);
}
int mm = min(n, t);
int T = mm, cnt = 0;
while (T--) {
cnt += n;
for (int i = 0; i < n; i++) a[i + cnt] = a[i];
}
int ans = 0;
int len = 1;
for (int i = 0; i < mm * n; i++) {
dp[i]++;
for (int j = 0; j < i; j++) {
if (a[i] >= a[j]) dp[i] = max(dp[i], dp[j] + 1);
}
len = max(len, dp[i]);
}
ans = len + (t - mm) * mnum;
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d ", &n);
n++;
vector<int> a(1 << n);
for (int i = 2; i < (1 << n); i++) {
scanf("%d\n", &a[i]);
}
vector<int> mx_left(1 << n), mx_right(1 << n);
int m = 1 << n;
for (int i = m - 1; i > 0; i--) {
if (i >= (1 << (n - 1))) {
mx_left[i] = 0;
mx_right[i] = 0;
} else {
int left = 2 * i;
int right = 2 * i + 1;
mx_left[i] = a[left] + max(mx_left[left], mx_right[left]);
mx_right[i] = a[right] + max(mx_left[right], mx_right[right]);
}
}
int allmx = max(mx_left[1], mx_right[1]), r = 0;
vector<int> add(m);
for (int i = 1; i < m / 2; i++) {
if (mx_left[i] + add[i] < allmx) {
int d = allmx - (mx_left[i] + add[i]);
r += d;
add[2 * i] = d;
}
add[2 * i] += add[i] + a[2 * i];
if (mx_right[i] + add[i] < allmx) {
int d = allmx - (mx_right[i] + add[i]);
r += d;
add[2 * i + 1] = d;
}
add[2 * i + 1] += add[i] + a[2 * i + 1];
}
printf("%d\n", r);
}
int main() {
solve();
return 0;
}
| 2 |
#include <stdio.h>
const long long mod = 1000000007;
long long inv[8080] = { 0,1 }, fact[8080] = { 1,1 }, ifact[8080] = { 1,1 };
long long count[4040][4040];
int main()
{
for (int i = 2; i < 8080; i++){
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
fact[i] = fact[i - 1] * i % mod;
ifact[i] = ifact[i - 1] * inv[i] % mod;
}
long long ans = 0;
int N; scanf ("%d", &N);
int A[200200], B[200200];
const int c = 2010;
for (int i = 0; i < N; i++){
scanf ("%d %d", &A[i], &B[i]);
count[c - A[i]][c - B[i]]++;
ans = (ans + mod - fact[(A[i] + B[i]) * 2] * ifact[A[i] * 2] % mod * ifact[B[i] * 2] % mod) % mod;
}
for (int i = 1; i <= c * 2; i++) for (int j = 1; j <= c * 2; j++){
count[i][j] = (count[i][j] + count[i - 1][j] + count[i][j - 1]) % mod;
}
for (int i = 0; i < N; i++) ans = (ans + count[c + A[i]][c + B[i]]) % mod;
ans = ans * inv[2] % mod;
printf ("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int inf = 1e9 + 1;
const int prime_100000000 = 5761460;
const double eps = 1e-15;
const double EPS = 1e-9;
const double PI = acos(-1.0);
int lucky_number[9] = {4, 7, 44, 47, 74, 77, 444, 447, 477};
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n, p, k;
cin >> n >> p >> k;
int ans = 0;
ans = p - k;
if (ans >= 1) {
if (ans == 1 && ans < p)
cout << 1 << " ";
else if (ans > 1 && ans < p) {
cout << "<< " << p - k << " ";
}
ans = ans + 1;
while (ans < p) {
cout << ans << " ";
ans++;
}
} else {
int i = 1;
while (i < p) {
cout << i << " ";
i++;
}
}
cout << "(" << p << ") ";
int flag = 0;
while (k--) {
p++;
if (p == n) {
cout << p << endl;
flag = 1;
break;
} else if (p > n) {
flag = 1;
break;
} else {
cout << p << " ";
}
}
if (flag == 0) cout << ">>";
}
| 1 |
#include <bits/stdc++.h>
const int N = 3e5 + 10;
const int mod = 998244353;
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T1, typename T2>
void addmo(T1 &a, T2 b) {
a += b;
if (a >= mod) a -= mod;
}
int n, f[N], sz[N];
long long ans;
vector<pair<int, int> > g[N];
int ok(int x) {
while (x) {
if (x % 10 != 4 && x % 10 != 7) return 0;
x /= 10;
}
return 1;
}
void dfs(int x, int pre) {
sz[x] = 1;
for (pair<int, int> i : g[x])
if (i.first ^ pre) {
dfs(i.first, x);
sz[x] += sz[i.first];
if (ok(i.second))
f[x] += sz[i.first];
else
f[x] += f[i.first];
}
}
void Dfs(int x, int pre) {
for (pair<int, int> i : g[x])
if (i.first ^ pre) {
if (ok(i.second))
f[i.first] += n - sz[i.first];
else
f[i.first] = f[x];
Dfs(i.first, x);
}
if (f[x] >= 2) ans += 1ll * f[x] * (f[x] - 1);
}
void Solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1, x, y, z; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
g[x].push_back({y, z}), g[y].push_back({x, z});
}
dfs(1, 0), Dfs(1, 0);
printf("%lld\n", ans);
}
signed main() {
int T = 1;
while (T--) Solve();
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define st first
#define nd second
typedef long long ll;
int n;
ll c[100005];
ll a[100005], b[100005];
ll dp[100005];
int main()
{
int t; cin>>t;
while(t--) {
int n; cin>>n;
for(int i = 1; i <= n; i++) {
cin>>c[i];
dp[i] = 0;
}
for(int i = 1; i <= n; i++) cin>>a[i];
for(int i = 1; i <= n; i++) {
cin>>b[i];
if(b[i] < a[i]) swap(a[i], b[i]);
}
ll ans = 0;
dp[n] = c[n] - 1 + 2;
ans = max(ans, dp[n] + b[n] - a[n]);
for(int i = n-1; i >= 2; i--) {
dp[i] = c[i] - 1 + 2;
ans = max(ans, dp[i] + b[i] - a[i]);
if(a[i+1]!=b[i+1]) {
dp[i] = max(dp[i], dp[i+1] + a[i+1] - 1 + c[i] - b[i+1] + 2);
}
ans = max(ans, dp[i] + b[i] - a[i]);
}
cout<<ans<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0l);
const long long MOD = 1e9 + 7;
bool debug = 1;
const int N = 1e2 + 10;
int n;
int g[5][5];
long long val[5][5];
long long f(vector<int> &v) {
long long ans = 0;
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < i + 1; j++) {
ans += val[v[i]][v[j]];
}
}
return ans;
}
int par[5];
int aux[5];
array<long long, 3> block[N];
int ok() {
int tot = 0;
for (int i = 0; i < 4; i++) tot += (par[i] ^ aux[i]);
return tot <= 2;
}
int vis[N];
int idnao;
void dfs(int no) {
vis[no] = 1;
for (int i = 0; i < n; i++) {
if (i == idnao) continue;
int it1 = block[i][0], it2 = block[i][2];
if (it1 == no and !vis[it2])
dfs(it2);
else if (it2 == no and !vis[it1])
dfs(it1);
}
return;
}
int conexo(int id) {
idnao = id;
memset(vis, 0, sizeof(vis));
dfs(0);
for (int i = 0; i < 4; i++)
if (!vis[i]) return 0;
return 1;
}
int main() {
long long ans = 0;
cin >> n;
long long soma = 0;
for (int i = 0; i < n; i++) {
int u, v;
long long x;
scanf("%d%lld%d", &u, &x, &v);
u--, v--;
block[i] = {u, x, v};
soma += x;
g[u][v]++, g[v][u]++;
par[u] = !par[u], par[v] = !par[v];
val[u][v] += x;
if (u != v) val[v][u] += x;
}
vector<int> p;
for (int i = 0; i < 4; i++) p.push_back(i);
int maxtam = 0;
do {
int tam = 0;
int it = -1;
vector<int> vcur;
for (int i = 0; i < 4; i++) {
int no = p[i];
if (it == -1) {
vcur.push_back(no);
tam++;
} else if (g[it][no]) {
vcur.push_back(no);
tam++;
} else {
break;
}
it = p[i];
}
maxtam = max(maxtam, tam);
ans = max(ans, f(vcur));
} while (next_permutation((p).begin(), (p).end()));
if (conexo(-1)) {
ans = 0;
if (ok()) ans = soma;
for (int i = 0; i < n; i++) {
memset(aux, 0, sizeof(aux));
if (block[i][0] != block[i][2]) {
aux[block[i][0]] = 1;
aux[block[i][2]] = 1;
}
if (ok() and conexo(i)) ans = max(ans, soma - block[i][1]);
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int n;
inline void addedge(int a,int b){printf("%d %d\n",a,b);}
int main()
{
scanf("%d",&n);
int vvv=1;
while(vvv<n) vvv<<=1;
if(vvv==n) return puts("No"),0;
puts("Yes");
for(int i=3;i<=n;i+=2)
{
addedge(1,i-1);addedge(i-1,i);
addedge(1,n+i);addedge(n+i,n+i-1);
}
addedge(3,1+n);
if(n%2==0)
{
int va=1;
while((n&va)==0) va<<=1;
addedge(n,va);
addedge(n+n,(va^n^1)+n);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int binarySearch(vector<int>& arr, int left, int right, long long int x,
bool is_left = false) {
if (!is_left) {
while (left < right) {
int mid = (left + right) / 2;
if (x < arr[mid])
right = mid;
else
left = mid + 1;
}
return left;
} else {
while (left < right) {
int mid = (left + right) / 2;
if (x <= arr[mid])
right = mid;
else
left = mid + 1;
}
return left;
}
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int modInverse(int a, int m) {
a = a % m;
for (int x = 1; x < m; x++)
if ((a * x) % m == 1) return x;
}
string reverseStr(string str) {
string result = str;
int n = str.length();
for (int i = 0; i < n / 2; i++) swap(result[i], result[n - i - 1]);
return result;
}
int parent[1000001];
int depth[1000001];
void make_set(int v) {
parent[v] = v;
depth[v] = 0;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (depth[a] < depth[b]) swap(a, b);
parent[b] = a;
if (depth[a] == depth[b]) ++depth[a];
}
}
int tree[32];
void build(vector<long long int> a, int v, int left, int right) {
if (left == right)
tree[v] = a[left];
else {
int tm = (left + right) / 2;
build(a, v * 2, left, tm);
build(a, v * 2 + 1, tm + 1, right);
tree[v] = max(tree[v * 2], tree[v * 2 + 1]);
}
}
int get_max(int v, int left, int right, int l, int r) {
if (l > r) return 0;
if (l == left && r == right) {
return tree[v];
}
int tm = (left + right) / 2;
return max(get_max(v * 2, left, tm, l, min(r, tm)),
get_max(v * 2 + 1, tm + 1, right, max(l, tm + 1), r));
}
void update(int v, int left, int right, int pos, int new_val) {
if (left == right)
tree[v] = new_val;
else {
int tm = (left + right) / 2;
if (pos <= tm)
update(v * 2, left, tm, pos, new_val);
else
update(v * 2 + 1, tm + 1, right, pos, new_val);
tree[v] = max(tree[v * 2], tree[v * 2 + 1]);
}
}
void bfs(vector<int> g[], bool used[]) {
queue<int> queue;
queue.push(1);
used[1] = true;
while (!queue.empty()) {
int u = queue.front();
queue.pop();
for (size_t i = 0; i < g[u].size(); ++i) {
int u = g[u][i];
if (!used[u]) {
used[u] = true;
queue.push(u);
}
}
}
}
int binpow(int a, int n) {
int res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
void reverse(int arr[], int n) {
for (int i = 0; i < n / 2; i++) swap(arr[i], arr[n - 1 - i]);
}
vector<int> cifar(long long int n) {
vector<int> ans;
while (n) {
ans.push_back(n % 10);
n = n / 10;
}
for (int i = 0; i < ans.size() / 2; i++)
swap(ans[i], ans[ans.size() - 1 - i]);
return ans;
}
long long mulmod(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;
}
vector<int> cl;
int dl[500][500] = {0};
int dp(vector<int>& cl) {
int n = cl.size();
if (n == 1) return 1;
int mn = 1000;
for (int i = 0; i < n; i++) mn = min(mn, cl[i]);
vector<int> ncl;
vector<int> ans1;
vector<int> ans2;
int i = 0;
while (i < n) {
int count = 0;
if (cl[i] == mn) {
while (i + count < n and cl[i + count] == mn) {
count++;
}
count++;
for (int j = 0; j < count / 2; j++) {
ncl.push_back(mn + 1);
ans1.push_back(dp(ncl));
if (count % 2) {
ncl.push_back(mn);
ans1.push_back(dp(ncl));
ncl.pop_back();
}
}
i += count;
} else {
ncl.push_back(cl[i]);
i++;
}
}
i = n - 1;
while (i >= 0) {
int count = 0;
if (cl[i] == mn) {
while (i - count >= 0 and cl[i - count] == mn) {
count++;
}
count++;
for (int j = 0; j < count / 2; j++) {
ncl.push_back(mn + 1);
ans1.push_back(dp(ncl));
if (count % 2) {
ncl.push_back(mn);
ans1.push_back(dp(ncl));
ncl.pop_back();
}
}
i += count;
} else {
ncl.push_back(cl[i]);
i++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
int cl[n];
vector<int> q;
long long int sm = 0;
for (int i = 0; i < n; i++) {
cin >> cl[i];
if (cl[i] > n - k) {
q.push_back(i);
sm += cl[i];
}
}
long long int ans = 1;
long long int mod = 998244353;
for (int i = 1; i < q.size(); i++) {
ans = mulmod(ans, q[i] - q[i - 1], mod);
}
cout << sm << ' ' << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, d, b;
int a[200007], cnt[200007], aa[200007];
bool calc(int dis, int pos) {
int t = (dis + d - 1) / d, tot = min(pos, n - pos + 1);
return (t <= tot);
}
bool check(int x) {
for (int i = 1; i <= n; i++) a[i] = aa[i];
for (int i = x + 1; i <= n; i++) cnt[i] = b;
int pos = x + 1;
for (int i = 1; i <= n; i++) {
while (a[i] > 0) {
if (calc(abs(pos - i), pos)) {
int del = min(a[i], cnt[pos]);
a[i] -= del;
cnt[pos] -= del;
if (cnt[pos] == 0) ++pos;
if (pos + x - 1 >= n) return true;
} else
break;
}
}
return false;
}
int main() {
scanf("%d%d%d", &n, &d, &b);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) aa[i] = a[i];
int lx = 0, rx = (n + 1) / 2;
while (rx - lx > 1) {
int mid = (lx + rx) / 2;
if (check(mid))
rx = mid;
else
lx = mid;
}
if (check(lx))
printf("%d\n", lx);
else
printf("%d\n", rx);
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main() {
int N, D;
cin >> N >> D;
cout << (2 * D + N) / (1 + 2 * D);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[2][55];
bool mark[2][55][55][26];
int dp[55][55], len[2];
int ecnt;
struct Edge {
int to, w;
Edge *next;
} * mat[26], edges[55];
void link(int x, int to, int w) {
edges[ecnt].w = w;
edges[ecnt].to = to;
edges[ecnt].next = mat[x];
mat[x] = &edges[ecnt++];
}
void deal(int k) {
len[k] = strlen(str[k]);
for (int i = 0; i < len[k]; i++) mark[k][i][i][(int)(str[k][i] - 'a')] = true;
for (int L = 2; L <= len[k]; L++)
for (int i = 0; i + L - 1 < len[k]; i++) {
int j = i + L - 1;
for (int t = i; t < j; t++)
for (int o = 0; o < 26; o++)
if (mark[k][i][t][o]) {
for (Edge *p = mat[o]; p; p = p->next) {
if (!mark[k][t + 1][j][p->to]) continue;
mark[k][i][j][p->w] = true;
}
}
}
}
void check(int &x, int y) {
if (x == -1 || x > y) x = y;
}
int main() {
scanf("%s%s", str[0], str[1]);
int n;
char x, y, ch, s[105];
scanf("%d", &n);
gets(s);
for (int i = 0; i < n; i++) {
gets(s);
sscanf(s, "%c%*c%*c%c%c", &ch, &x, &y);
link(x - 'a', y - 'a', ch - 'a');
}
deal(0);
deal(1);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < len[0]; i++)
for (int j = 0; j < len[1]; j++) {
if (dp[i][j] == -1) continue;
for (int g = i; g < len[0]; g++)
for (int k = 0; k < 26; k++)
if (mark[0][i][g][k])
for (int h = j; h < len[1]; h++)
if (mark[1][j][h][k]) check(dp[g + 1][h + 1], dp[i][j] + 1);
}
printf("%d\n", dp[len[0]][len[1]]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int match(string s1) {
string s[11] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
for (int i = 0; i < 11; i++) {
if (s[i] == s1) return 1;
}
return 0;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
string s1;
int n, c = 0, i;
cin >> n;
while (n--) {
cin >> s1;
if (isdigit(s1[0])) {
if (stoi(s1) < 18) c++;
}
if (match(s1)) c++;
}
cout << c << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
cin >> s[i];
}
vector<vector<int>> dist(h, vector<int>(w, -1));
vector<pair<int, int>> qe;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (s[i][j] == '.') {
continue;
}
int border = 0;
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (i + di < 0 || j + dj < 0 || i + di >= h || j + dj >= w ||
s[i + di][j + dj] == '.') {
border = 1;
break;
}
}
}
if (border) {
dist[i][j] = 0;
qe.emplace_back(i, j);
}
}
}
for (int b = 0; b < (int)qe.size(); b++) {
int i = qe[b].first;
int j = qe[b].second;
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (i + di < 0 || j + dj < 0 || i + di >= h || j + dj >= w ||
s[i + di][j + dj] == '.' || dist[i + di][j + dj] != -1) {
continue;
}
dist[i + di][j + dj] = dist[i][j] + 1;
qe.emplace_back(i + di, j + dj);
}
}
}
vector<vector<bool>> was(h, vector<bool>(w, false));
vector<tuple<int, int, int>> que;
int low = 0, high = (min(h, w) - 1) / 2;
while (low < high) {
int mid = (low + high + 1) >> 1;
que.clear();
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (dist[i][j] >= mid) {
que.emplace_back(i, j, 0);
was[i][j] = true;
} else {
was[i][j] = false;
}
}
}
bool fail = false;
for (int b = 0; b < (int)que.size(); b++) {
int i = get<0>(que[b]);
int j = get<1>(que[b]);
int d = get<2>(que[b]);
if (d == mid) {
break;
}
for (int di = -1; di <= 1; di++) {
for (int dj = -1; dj <= 1; dj++) {
if (i + di >= 0 && j + dj >= 0 && i + di < h && j + dj < w) {
if (s[i + di][j + dj] == '.') {
fail = true;
break;
}
if (!was[i + di][j + dj]) {
was[i + di][j + dj] = true;
que.emplace_back(i + di, j + dj, d + 1);
}
} else {
fail = true;
break;
}
}
}
if (fail) {
break;
}
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (!was[i][j] && s[i][j] == 'X') {
fail = true;
break;
}
}
if (fail) {
break;
}
}
if (fail) {
high = mid - 1;
} else {
low = mid;
}
}
cout << low << '\n';
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (dist[i][j] < low) {
s[i][j] = '.';
}
}
cout << s[i] << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
vector<int> v;
for (string u : {"twone", "two", "one"}) {
for (int i = 0; (i = s.find(u, i)) != string::npos;) {
s[i + u.length() / 2] = '?';
v.push_back(i + u.length() / 2);
}
}
cout << v.size() << "\n";
for (auto u : v) cout << u + 1 << " ";
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s, ans;
cin >> s;
if (n % 2 == 1)
for (int i = 0; i < n; ++i) {
if (i % 2 == 0) {
ans += s[i];
} else {
ans = s[i] + ans;
}
}
else
for (int i = 0; i < n; ++i) {
if (i % 2 == 1) {
ans += s[i];
} else {
ans = s[i] + ans;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T;
int uf[5000031];
int coun[5000031];
bool findvis[200100];
int find(int x) {
if (x == uf[x] || uf[x] == 0) return x;
return uf[x] = find(uf[x]);
}
void unio(int x, int y) {
if (find(x) == find(y)) return;
coun[find(x)] += coun[find(y)];
uf[find(y)] = uf[find(x)];
}
int N, K;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> K;
int i;
for (i = 1; i <= N; i++) {
coun[i] = 1;
uf[i] = i;
}
for (i = 0; i < K; i++) {
int a, b;
cin >> a >> b;
unio(a, b);
}
int ans = 0;
for (i = 1; i <= N; i++) {
if (!findvis[find(i)]) {
ans += coun[find(i)] - 1;
findvis[find(i)] = true;
}
}
cout << K - ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "yes" : "no");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long double lg[200135];
struct SuffixArray {
int sa[200135], rk[200135], height[200135];
int c[200135], x[200135], y[200135];
void get_SA1(const char *s, int n, int m = 122) {
for (int(i) = 1; (i) <= (int)(n); (i)++) ++c[x[i] = s[i]];
for (int i = 2; i <= m; ++i) c[i] += c[i - 1];
for (int i = n; i >= 1; --i) sa[c[x[i]]--] = i;
for (int k = 1; k <= n; k <<= 1) {
int num = 0;
for (int i = n - k + 1; i <= n; ++i) y[++num] = i;
for (int i = 1; i <= n; ++i)
if (sa[i] > k) y[++num] = sa[i] - k;
for (int i = 1; i <= m; ++i) c[i] = 0;
for (int i = 1; i <= n; ++i) ++c[x[i]];
for (int i = 2; i <= m; ++i) c[i] += c[i - 1];
for (int i = n; i >= 1; --i) {
sa[c[x[y[i]]]--] = y[i];
y[i] = 0;
}
swap(x, y);
x[sa[1]] = 1;
num = 1;
for (int i = 2; i <= n; ++i)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k])
? num
: ++num;
if (num == n) break;
m = num;
}
}
void get_height(const char *s, int n) {
int k = 0;
for (int i = 1; i <= n; ++i) rk[sa[i]] = i;
for (int i = 1; i <= n; ++i) {
if (rk[i] == 1) continue;
if (k) --k;
int j = sa[rk[i] - 1];
while (j + k <= n && i + k <= n && s[i + k] == s[j + k]) ++k;
height[rk[i]] = k;
}
}
void ppTest(const char *s, int n) {
for (int(i) = 1; (i) <= (int)(n); (i)++) {
printf("%d: %d ", i, sa[i]);
for (int j = sa[i]; j <= n; j++) printf("%c", s[j]);
puts("");
}
}
} sa;
struct SuffixStQuery {
int T[200135][20];
void init(int n) {
for (int(i) = 1; (i) <= (int)(n); (i)++) T[i][0] = sa.height[i];
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
T[i][j] = min(T[i][j - 1], T[i + (1 << (j - 1))][j - 1]);
}
}
for (int(i) = 1; (i) <= (int)(n); (i)++) lg[i] = log(i);
}
int qym(int l, int r) {
if (r < l) swap(l, r);
int x = lg[r - l + 1] / lg[2];
int y = min(T[l][x], T[r - (1 << x) + 1][x]);
return y;
}
} stQuery;
char S[200135];
int Q, ls, lt;
int cmpStr(int i, int j, int len) {
if (i == j) return 0;
int lcp = stQuery.qym(min(sa.rk[i], sa.rk[j]) + 1, max(sa.rk[i], sa.rk[j]));
if (len <= lcp) return 0;
assert(i + lcp <= ls + lt && j + lcp <= ls + lt);
assert(S[i + lcp] != S[j + lcp]);
return S[i + lcp] < S[j + lcp] ? 1 : -1;
}
int cmp(int p1, int p2) {
if (p1 == p2) return 0;
if (p1 > p2) return -cmp(p2, p1);
if (p1 + lt >= p2 + 1) {
int z = cmpStr(ls + 1, p1 + 1, p2 - p1);
if (z != 0) return z;
int cc = p2 - p1;
z = cmpStr(ls + 1 + cc, ls + 1, lt - cc);
if (z != 0) return z;
cc = lt - cc;
return cmpStr(p1 + 1, ls + 1 + cc, lt - cc);
} else {
int z = cmpStr(ls + 1, p1 + 1, lt);
if (z != 0) return z;
z = cmpStr(p1 + 1, p1 + 1 + lt, p2 + 1 - (p1 + 1 + lt));
if (z != 0) return z;
int cc = p2 + 1 - (p1 + 1 + lt);
return cmpStr(p1 + 1 + cc, ls + 1, lt);
}
}
bool smp(int a, int b) {
int z = cmp(a, b);
if (z == 0) return a < b;
return z == 1;
}
int ynk[200135], rid[200135];
void init() {
sa.get_SA1(S, ls + lt);
sa.get_height(S, ls + lt);
stQuery.init(ls + lt);
n = ls;
for (int(i) = 1; (i) <= (int)(n); (i)++) ynk[i] = i;
sort(ynk, ynk + n + 1, smp);
for (int i = 0; i <= n; i++) rid[ynk[i]] = i;
}
struct mb {
int l, r, x, y, k, id;
void rd(int i) {
scanf("%d%d%d%d%d", &l, &r, &k, &x, &y);
id = i;
}
} q[200135];
vector<int> ks[200135];
int sq, L[200135], R[200135], Ans[200135];
int sT[200135][20];
int qym(int l, int r) {
if (r < l) swap(l, r);
int x = lg[r - l + 1] / lg[2];
int y = min(sT[l][x], sT[r - (1 << x) + 1][x]);
return y;
}
int gid(int K, int k, int x) {
int z = x / K;
if ((x % K) >= k) z++;
return z;
}
void deal(int K) {
int cnt = 0;
for (int i = 0; i < K; i++) {
L[i] = -1;
R[i] = -1;
for (int j = i; j <= n; j += K) {
++cnt;
sT[cnt][0] = rid[j];
if (j == i) L[i] = cnt;
}
R[i] = cnt;
}
for (int j = 1; (1 << j) <= cnt; j++) {
for (int i = 1; i + (1 << j) - 1 <= cnt; i++) {
sT[i][j] = min(sT[i][j - 1], sT[i + (1 << (j - 1))][j - 1]);
}
}
for (int qid : ks[K]) {
for (int j = q[qid].x; j <= q[qid].y; j++) {
if (L[j] == -1) continue;
int x = gid(K, j, q[qid].l), y = gid(K, j, q[qid].r);
int X = L[j] + x - 1;
int Y = L[j] + y - 1;
if (q[qid].l % K != j) X++;
if (Y < X) continue;
Ans[qid] = min(Ans[qid], qym(X, Y));
}
}
}
void fmain() {
scanf("%s", S + 1);
ls = strlen(S + 1);
scanf("%s", S + ls + 1);
lt = strlen(S + 1 + ls);
scanf("%d", &Q);
init();
for (int(i) = 1; (i) <= (int)(Q); (i)++) {
q[i].rd(i);
ks[q[i].k].push_back(i);
Ans[i] = (1 << 30);
}
sq = 77;
for (int(i) = 1; (i) <= (int)(sq); (i)++) deal(i);
for (int i = 0; i <= n; i++) sT[i + 1][0] = rid[i];
for (int j = 1; (1 << j) <= n + 1; j++) {
for (int i = 1; i + (1 << j) - 1 <= n + 1; i++) {
sT[i][j] = min(sT[i][j - 1], sT[i + (1 << (j - 1))][j - 1]);
}
}
for (int K = sq + 1; K <= n; K++)
if (!ks[K].empty()) {
for (int qid : ks[K]) {
for (int i = q[qid].x, j = q[qid].y; i <= n; i += K, j += K) {
int x = max(i, q[qid].l), y = min(j, q[qid].r);
if (y < x) continue;
Ans[qid] = min(Ans[qid], qym(x + 1, y + 1));
}
}
}
for (int(i) = 1; (i) <= (int)(Q); (i)++) {
if (Ans[i] == (1 << 30))
printf("-1 ");
else
printf("%d ", ynk[Ans[i]]);
}
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if (n <= 1) {
printf("0");
} else {
printf("%d", min(a, b) + (n - 2) * min(a, min(b, c)));
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int m;
int t[3]={0};
while(cin>>m){
for(int i=0;i<3;i++)
if(m>t[i]) swap(t[i],m);
}
for(int i=0;i<3;i++){
cout<<t[i]<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i;
int answer = 1;
for (i = 2; i <= n; i++) {
answer += (6 * (2 * i - 2));
}
cout << answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
namespace ModCalculator {
int MOD;
inline void Inc(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
inline void Dec(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
inline int Add(int x, int y) {
Inc(x, y);
return x;
}
inline int Sub(int x, int y) {
Dec(x, y);
return x;
}
inline int Mul(int x, int y) { return 1LL * x * y % MOD; }
inline int ksm(int x, int k) {
int ret = 1;
for (; k; k >>= 1) {
if (k & 1) ret = Mul(ret, x);
x = Mul(x, x);
}
return ret;
}
inline int Inv(int x) { return ksm(x, MOD - 2); }
} // namespace ModCalculator
using namespace ModCalculator;
int N, D;
int inv[MAXN], dp[MAXN][11][MAXN];
int DP(int n, int d, int k) {
k = min(k, n - 1);
if (n == 1) return (d == 0 || d == D - 1);
if (!k) return 0;
if (~dp[n][d][k]) return dp[n][d][k];
int ret = DP(n, d, k - 1);
int son = DP(k, D - 1, k), C = 1;
for (int i = 1; i <= d && i * k < n; ++i) {
C = Mul(C, Mul(son + i - 1, inv[i]));
Inc(ret, Mul(C, DP(n - i * k, d - i, k - 1)));
}
return dp[n][d][k] = ret;
}
void solve() {
read(N);
read(D);
read(MOD);
if (N <= 2) {
puts("1");
return;
}
inv[0] = inv[1] = 1;
for (int i = 2; i <= N; ++i) {
inv[i] = Mul(MOD - MOD / i, inv[MOD % i]);
}
memset(dp, -1, sizeof(dp));
int ans = DP(N, D, (N - 1) / 2);
if (N % 2 == 0) {
int half = DP(N / 2, D - 1, N / 2 - 1);
Inc(ans, Mul(Mul(half, half + 1), inv[2]));
}
printf("%d\n", ans);
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> a(n);
set<int> s;
for (int i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
};
if ((int)s.size() == 1) {
cout << 1 << '\n';
for (int i = 0; i < n; i++)
cout << 1 + ((69 ^ 4) - (420 & 69) - (69 & 69) + (int)sqrt(69)) << " ";
return;
}
if (n % 2 == 0) {
cout << 2 << "\n";
for (int i = 0; i < n; i++) {
cout << (i & 1) + 1 << " ";
}
cout << '\n';
return;
}
for (int i = 0; i < n; i++) {
if (a[i] == a[(i + 1) % n]) {
vector<int> v(n);
cout << "2\n";
for (int par = 0, j = i + 1; j < n; j++, par ^= 1) {
v[j] = 1 + par;
}
for (int par = 0, j = i; j >= 0; j--, par ^= 1) {
v[j] = 1 + par;
}
for (int i = 0; i < n; i++) cout << v[i] << " ";
cout << "\n";
return;
}
}
cout << "3\n";
for (int i = 0; i + 1 < n; i++) {
cout << 1 + ((i & 1) ^ 0) +
((69 ^ 4) - (420 & 69) - (69 & 69) + (int)sqrt(69))
<< " ";
}
cout << "3\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void) {
int n, a;
vector<int> L;
int l = 1;
cin >> n;
cin >> a;
L.push_back(a);
for (int i = 1; i < n; i++)
{
cin >> a;
vector<int>::iterator pos = lower_bound(L.begin(), L.end(), a);
if (pos == L.end()) {
L.push_back(a);
l++;
}
else {
*pos = a;
}
}
cout << l << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
map<string,int> mp;
vector<string> nlst;
int getId(string s){
if(mp.count(s))
return mp[s];
int id = mp.size();
nlst.push_back(s);
return mp[s] = id;
}
int readId(){
string s;cin>>s;return getId(s);
}
int n;
vector<int> lst[321][321];
vector<int> src[1234],dst[1234];
bool done[1234];
bool reach[321][321];
int main(){
int A=readId(),B=readId();
cin>>n;
rep(it,n){
int m;cin>>m;
rep(i,m){
int u = readId(), v = readId();
lst[u][v].push_back(it);
src[it].push_back(u);
dst[it].push_back(v);
}
}
queue<int> que;
que.push(A),que.push(B);
reach[A][B] = 1;
while(!que.empty()){
int x = que.front();que.pop();
int y = que.front();que.pop();
//cout<<nlst[x]<<" "<<nlst[y]<<endl;
rep(it,lst[x][y].size()){
int id = lst[x][y][it];
if(done[id])
continue;
done[id]=true;
rep(t,src[id].size()){
int u =src[id][t],v = dst[id][t];
if(!reach[u][v]){
reach[u][v]=1;
que.push(u),que.push(v);
}
}
}
rep(xx,mp.size()) if(reach[xx][x] && !reach[xx][y]) {reach[xx][y] = 1;que.push(xx);que.push(y);}
rep(yy,mp.size()) if(reach[y][yy] && !reach[x][yy]) {reach[x][yy] = 1;que.push(x);que.push(yy);}
}
bool ok = 1;
rep(i,mp.size()) if(reach[i][i]) ok = 0;
puts(ok?"Yes":"No");
}
| 0 |
#include <cstdio>
#include <complex>
using namespace std;
typedef complex<double> xy_t;
xy_t P[110];
int main(){
int N;
scanf("%d", &N);
for (int i=0; i<N; i++){
double x, y;
scanf("%lf %lf", &x, &y);
P[i] = xy_t(x,y);
}
double sum = 0.0;
for (int i=2; i<N; ++i){
xy_t a=P[0], b=P[i-1], c=P[i];
sum += 0.5*((b.real()-a.real())*(c.imag()-a.imag())
-(b.imag()-a.imag())*(c.real()-a.real()));
}
printf("%.1f\n", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e5 + 10;
vector<int> dsu, adj[maxN], sz;
vector<bool> visited;
int n, m, q, c, a, b;
inline int div2(int a) { return (a + 1) / 2; }
void Merge(int a, int b);
void Flat(int x);
pair<int, int> getFar(int p, int c) {
visited[c] = true;
pair<int, int> pp = {0, c}, pr;
for (int u : adj[c]) {
if (u == p) continue;
pr = getFar(c, u);
pr.first++;
pp = max(pp, pr);
}
return pp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> m >> q;
dsu.resize(n + 1);
iota(dsu.begin(), dsu.end(), 0);
sz.resize(n + 1);
visited.resize(n + 1);
fill(visited.begin(), visited.end(), false);
for (int i = 0; i < m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
Merge(a, b);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
pair<int, int> res = getFar(i, i);
res = getFar(res.second, res.second);
Flat(i);
sz[dsu[i]] = res.first;
}
}
while (q--) {
cin >> c;
if (c == 1) {
cin >> a;
Flat(a);
cout << sz[a] << endl;
} else if (c == 2) {
cin >> a >> b;
Merge(a, b);
}
}
}
void Flat(int x) {
if (dsu[x] == x) return;
Flat(dsu[x]);
sz[x] = sz[dsu[x]];
dsu[x] = dsu[dsu[x]];
}
void Merge(int a, int b) {
Flat(a);
Flat(b);
if (dsu[a] == dsu[b]) return;
sz[dsu[b]] = max(max(sz[a], sz[b]), (div2(sz[a]) + div2(sz[b]) + 1));
dsu[dsu[a]] = dsu[b];
}
| 5 |
#include <bits/stdc++.h>
int n, k;
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &k);
if (k % 3) {
if (n % 3)
printf("Alice\n");
else
printf("Bob\n");
} else {
n %= k + 1;
if (n == k || n % 3)
printf("Alice\n");
else
printf("Bob\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[100005], sumb[100005], n, A, cf, cm, m,
summ = 0, newmi = 0, newcoun = 0, temp[100005];
vector<long long int> vec;
vector<pair<long long int, long long int> > a;
vector<long long int>::iterator it;
int main() {
cin >> n >> A >> cf >> cm >> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
a.push_back({arr[i], i});
temp[i] = arr[i];
}
sort(arr, arr + n);
sort(a.begin(), a.end());
vec.push_back(0);
for (int i = 0; i < n - 1; i++) {
summ = summ + (arr[i + 1] - arr[i]) * (long long int)(i + 1);
vec.push_back(summ);
}
sumb[0] = 0;
for (int i = 1; i <= n; i++) sumb[i] = A - arr[n - i] + sumb[i - 1];
long long int coun = 0, ans = 0;
for (int i = 0; i <= n; i++) {
long long int kp = m;
long long int lef = sumb[i];
if (lef <= kp) {
kp = kp - lef;
it = upper_bound(vec.begin(), vec.end(), kp);
if (it == vec.end()) it--;
if (*it > kp) it--;
if (it + 1 != vec.end() && *(it + 1) <= kp) it++;
int pos = it - vec.begin();
if (pos > n - 1 - i) pos = n - 1 - i;
if (pos < 0) break;
long long int mi = arr[pos];
kp = kp - vec[pos];
mi = mi + kp / (pos + 1);
if (mi >= A) {
cout << n * cf + cm * A << endl;
for (int i = 0; i < n; i++) cout << A << " ";
cout << endl;
return 0;
}
if (cf * i + mi * cm >= ans) {
newmi = mi;
newcoun = i;
ans = cf * i + mi * cm;
}
} else
break;
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
if (temp[i] <= newmi) temp[i] = newmi;
}
int lll = n - 1;
while (newcoun--) {
int pos = a[lll].second;
temp[pos] = A;
lll--;
}
for (int i = 0; i < n; i++) cout << temp[i] << " ";
cout << endl;
}
| 4 |
#include<iostream>
using namespace std;
int main(){
int x,a,b,c,ans=0;
cin >> a >> b >> c >> x;
for(int i=0;i<=a;i++)
for(int j=0;j<=b;j++)
for(int q=0;q<=c;q++)
if(i*500+j*100+q*50==x)
ans++;
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 113;
vector<long long> v[27][N];
signed main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
string s;
long long k;
cin >> s >> k;
k--;
vector<long long> indexes;
for (long long i = 0; i < s.size(); i++) indexes.push_back(i);
long long n = s.size();
if (k >= (n * (n + 1)) / 2) {
cout << "No such line." << endl;
return 0;
}
for (long long step = 0; step <= s.size(); step++) {
if (step && indexes.size() > k) {
for (long long i = indexes[0]; i < indexes[0] + step; i++) cout << s[i];
return 0;
}
if (step) k -= indexes.size();
for (auto i : indexes) {
if (i + step == s.size())
v[0][step].push_back(i);
else
v[s[i + step] - 'a' + 1][step].push_back(i);
}
indexes.clear();
for (long long i = 0; i < 27; i++) {
long long sum = 0;
for (auto j : v[i][step]) sum += s.size() - j - step;
if (sum > k) {
for (auto j : v[i][step]) indexes.push_back(j);
break;
}
k -= sum;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int i, count = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
count++;
i += 2;
}
}
printf("%d", count);
return 0;
}
| 2 |
#include<iostream>
#include<string>
using namespace std;
int main(){string n;int a,p;
for(int i=0;i<9;i++)cin>>n>>a>>p,cout<<n<<" "<<a+p<<" "<<a*200+p*300<<endl;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T nrem(T x, T y) {
return ((x % y) + y) % y;
}
void in() {}
string s[51];
bool check(int x1, int y1, int x2, int y2) {
int f = 0, g = 0;
for (int i = min(x1, x2); i <= max(x1, x2); ++i)
if (s[i][y1] != 'B') f = 1;
for (int i = min(y1, y2); i <= max(y1, y2); ++i)
if (s[x2][i] != 'B') f = 1;
for (int i = min(x1, x2); i <= max(x1, x2); ++i)
if (s[i][y2] != 'B') g = 1;
for (int i = min(y1, y2); i <= max(y1, y2); ++i)
if (s[x1][i] != 'B') g = 1;
if (!f || !g)
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
in();
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
vector<pair<int, int>> rem;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'B') rem.push_back(make_pair(i, j));
}
for (int i = 0; i < rem.size() - 1; ++i)
for (int j = i + 1; j < rem.size(); ++j) {
if (check(rem[i].first, rem[i].second, rem[j].first, rem[j].second))
continue;
return cout << "NO"
<< "\n",
0;
}
cout << "YES"
<< "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n >> a;
if (a % 2 != 0)
cout << ((a >> 1) + 1) << endl;
else
cout << (((n - a) >> 1) + 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long double v[110];
long double f[110];
int main() {
int n;
scanf("%d", &n);
if (n <= 4) {
printf("No solution\n");
return 0;
}
for (int i = 0; i < n; i++) v[i] = 500;
srand(time(0));
long double theta = (acos(-1) * (n - 2)) / n;
while (1) {
for (int i = 0; i < n; i++) {
int a = (i - 1 + n) % n;
int b = (i + 1) % n;
long double r = (long double)(rand() % 1200 + 800) / 100;
v[i] -= 2.0 * r;
v[a] -= r / cos(theta);
v[b] -= r / cos(theta);
}
int ok = 1;
for (int i = 0; i < n; i++) f[i] = v[i];
sort(f, f + n);
for (int i = 1; i < n; i++)
if (f[i] - f[i - 1] < .002) ok = 0;
if (ok) break;
}
long double x = 0, y = 0;
long double dx = 1, dy = 0;
for (int i = 0; i < n; i++) {
printf("%.8lf %.8lf\n", (double)x, (double)y);
x += dx * v[i];
y += dy * v[i];
long double aux = dx;
dx = -dx * cos(theta) - dy * sin(theta);
dy = aux * sin(theta) - dy * cos(theta);
};
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j;
char a[3][3];
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++) {
a[i][j] = '.';
}
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++) {
cin >> a[i][j];
}
if (a[0][0] == a[2][2] && a[0][1] == a[2][1] && a[0][2] == a[2][0] &&
a[1][0] == a[1][2])
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> negs;
set<pair<int, int>> poses;
map<int, int> posTotals;
vector<pair<int, int>> equals;
for (int i = 0; i < n; i++) {
string seq;
cin >> seq;
int diff = 0;
int diffMax = 0;
for (int j = 0; j < seq.length(); j++) {
if (seq[j] == ')')
diff += 1;
else
diff -= 1;
diffMax = max(diff, diffMax);
}
int total = -diff;
if (total < 0 && diffMax == -total)
negs.push_back(total);
else if (total > 0 && diffMax <= 0) {
if (posTotals.count(total))
posTotals[total]++;
else
posTotals[total] = 1;
} else if (total == 0 && diffMax <= 0)
equals.push_back(make_pair(diffMax, i));
}
int c = 0;
c += equals.size() / 2;
for (auto e : negs) {
if (posTotals.count(-e) && posTotals[-e] > 0) {
posTotals[-e]--;
c++;
}
}
cout << c << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
bool flag;
char str[3010];
int main() {
scanf("%s", str + 1), n = strlen(str + 1);
for (int i = 1; i <= n; ++i) {
if (str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' ||
str[i] == 'u')
flag = cnt = 0;
else {
flag |= cnt && (str[i] != str[i - 1]), ++cnt;
if (cnt >= 3 && flag) cnt = 1, flag = 0, putchar(' ');
}
putchar(str[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int dcmp(double x, double y) {
return fabs(x - y) <= 1e-9 ? 0 : x < y ? -1 : 1;
}
char letters[26] = {'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'};
const int dx[] = {0, -1, 0, 1, -1, -1, 1, 1};
const int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
long long t, n, arr[100010], celluar[100010], m;
pair<long long, long long> coverage[100010];
bool Ok(long long mid) {
for (int i = 0; i < m; ++i) {
coverage[i] = make_pair(celluar[i] - mid, celluar[i] + mid);
}
int idx = 0, numCovered = 0;
for (int i = 0; i < n; ++i) {
bool found = false;
for (int j = idx; j < m; ++j) {
if (arr[i] >= coverage[j].first && arr[i] <= coverage[j].second) {
idx = j;
found = true;
numCovered++;
break;
}
}
if (!found) return false;
}
if (numCovered == n) return true;
return false;
}
long long binarySearch() {
long long lo = 0, hi = 1e11, ans = -1;
while (lo <= hi) {
long long mid = lo + (hi - lo) / 2;
if (Ok(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
return ans;
}
int x;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
set<int> mySet;
for (int i = 0; i < m; i++) {
cin >> x;
mySet.insert(x);
}
long long ans = -1e9;
for (int i = 0; i < n; ++i) {
set<int>::iterator nearestCelluar = mySet.lower_bound(arr[i]);
set<int>::iterator begin = mySet.begin();
set<int>::iterator rBegin = mySet.end();
if (nearestCelluar == begin) {
ans = max(abs(*nearestCelluar * 1LL - arr[i]), ans);
} else if (nearestCelluar == mySet.end()) {
ans = max(abs(*mySet.rbegin() * 1LL - arr[i]), ans);
} else {
long long dist = abs(*nearestCelluar * 1LL - arr[i]);
nearestCelluar--;
dist = min(dist, abs(arr[i] * 1LL - *nearestCelluar));
ans = max(ans, dist);
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long inf = 100000000000000000;
struct pt {
long long x, y;
};
bool fun(pt a, pt b) { return a.x < b.x; }
long long f(long long maxx, long long minx, long long maxy, long long miny) {
long long v1 = 0, modx, mody;
modx = max(abs(maxx), abs(minx));
if (miny != inf) {
v1 = maxy - miny;
v1 *= v1;
mody = max(abs(maxy), abs(miny));
v1 = max(v1, mody * mody + modx * modx);
return v1 - ((maxx - minx) * (maxx - minx));
} else {
return -1 * (maxx - minx) * (maxx - minx);
}
}
long long g(long long maxx, long long minx, long long maxy, long long miny) {
long long v1 = 0, modx, mody;
modx = max(abs(maxx), abs(minx));
if (miny != inf) {
v1 = maxy - miny;
v1 *= v1;
mody = max(abs(maxy), abs(miny));
v1 = max(v1, mody * mody + modx * modx);
return max(v1, (maxx - minx) * (maxx - minx));
} else {
return (maxx - minx) * (maxx - minx);
}
}
int main() {
int n;
cin >> n;
vector<pt> A(n);
for (int i = 0; i < n; i++) cin >> A[i].x >> A[i].y;
sort(A.begin(), A.end(), fun);
long long fin = inf;
for (int jy = 0; jy < 2; jy++) {
vector<long long> pminy(n + 1, inf), sminy(n + 1, inf), pmaxy(n + 1, -inf),
smaxy(n + 1, -inf);
for (int i = 1; i <= n; i++) {
pminy[i] = min(A[i - 1].y, pminy[i - 1]);
pmaxy[i] = max(A[i - 1].y, pmaxy[i - 1]);
}
for (int i = n - 1; i >= 0; i--) {
sminy[i] = min(sminy[i + 1], A[i].y);
smaxy[i] = max(smaxy[i + 1], A[i].y);
}
long long ans = min(A[n - 1].x - A[0].x, pmaxy[n] - pminy[n]), val;
ans *= ans;
for (int i = n - 1; i >= 0; i--) {
if (A[i].x < 0) break;
val = inf;
int lp = 0, rp = i, pos, mid;
if (A[lp].x >= -A[i].x)
pos = lp;
else {
while (rp != lp + 1) {
mid = (lp + rp) / 2;
if (A[mid].x >= -A[i].x)
rp = mid;
else {
lp = mid;
}
}
pos = rp;
}
int lo = pos, hi = i;
if (f(A[i].x, A[lo].x, max(pmaxy[lo], smaxy[i + 1]),
min(pminy[lo], sminy[i + 1])) >= 0) {
ans = min(ans, g(A[i].x, A[lo].x, max(pmaxy[lo], smaxy[i + 1]),
min(pminy[lo], sminy[i + 1])));
} else {
if (f(A[i].x, A[hi].x, max(pmaxy[hi], smaxy[i + 1]),
min(pminy[hi], sminy[i + 1])) <= 0) {
ans = min(ans, g(A[i].x, A[hi].x, max(pmaxy[hi], smaxy[i + 1]),
min(pminy[hi], sminy[i + 1])));
} else {
while (hi != lo + 1) {
mid = (hi + lo) / 2;
if (f(A[i].x, A[mid].x, max(pmaxy[mid], smaxy[i + 1]),
min(pminy[mid], sminy[i + 1])) >= 0) {
hi = mid;
} else {
lo = mid;
}
}
ans = min(ans, g(A[i].x, A[hi].x, max(pmaxy[hi], smaxy[i + 1]),
min(pminy[hi], sminy[i + 1])));
ans = min(ans, g(A[i].x, A[lo].x, max(pmaxy[lo], smaxy[i + 1]),
min(pminy[lo], sminy[i + 1])));
}
}
}
fin = min(ans, fin);
vector<pt> tmp;
for (int i = n - 1; i >= 0; i--) {
A[i].x *= -1;
tmp.push_back(A[i]);
}
A = tmp;
}
cout << fin << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
long long a[maxn], b[maxn];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sort(a, a + n);
for (int i = 0; i < m; i++) {
scanf("%lld", &b[i]);
int cnt = upper_bound(a, a + n, b[i]) - a;
printf("%d ", cnt);
}
printf("\n");
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin>>n;
cout<<(n<=999?"ABC":"ABD");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100010, M = 1000010, INF = 0x3f3f3f3f;
inline long long Max(long long x, long long y) { return x > y ? x : y; }
inline long long Min(long long x, long long y) { return x < y ? x : y; }
inline void Swap(long long &x, long long &y) { x ^= y ^= x ^= y; }
long long n, m, p, head = 1, tail, d[N], h[N], t[N], a[N], que[N], sum[N],
f[110][N];
inline long long Y(long long i, long long k) { return f[i - 1][k] + sum[k]; }
inline long long K(long long j) { return a[j]; }
inline long long X(long long k) { return k; }
inline long long B(long long i, long long j) {
return f[i][j] - a[j] * j + sum[j];
}
inline long double slope(long long i, long long j, long long k) {
return (long double)(Y(i, k) - Y(i, j)) / (X(k) - X(j));
}
int main() {
scanf("%lld%lld%lld", &n, &m, &p);
for (long long i = 2; i <= n; i++) scanf("%lld", &d[i]), d[i] += d[i - 1];
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld", &h[i], &t[i]);
a[i] = t[i] - d[h[i]];
}
sort(a + 1, a + m + 1);
for (long long i = 1; i <= m; i++) sum[i] = sum[i - 1] + a[i];
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (long long i = 1; i <= p; i++) {
head = 1, tail = 0;
que[++tail] = 0;
for (long long j = 1, k; j <= m; j++) {
while (head < tail && slope(i, que[head], que[head + 1]) <= K(j)) ++head;
k = que[head], f[i][j] = f[i - 1][k] + a[j] * (j - k) - (sum[j] - sum[k]);
while (head < tail &&
slope(i, que[tail - 1], que[tail]) >= slope(i, que[tail - 1], j))
--tail;
que[++tail] = j;
}
}
printf("%lld\n", f[p][m]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 2e9;
int main() {
int n;
cin >> n;
vector<int> cnt(2e5 + 1, 0);
vector<int> inc, dec;
for (int i = 0; i < (n); i++) {
int a;
cin >> a;
cnt[a]++;
if (cnt[a] >= 3) {
cout << "NO" << endl;
return 0;
}
if (cnt[a] == 1)
inc.emplace_back(a);
else
dec.emplace_back(a);
}
sort(inc.begin(), inc.end());
sort(dec.begin(), dec.end(), greater<int>());
cout << "YES" << endl;
cout << inc.size() << endl;
for (auto e : inc) cout << e << " ";
cout << endl;
cout << dec.size() << endl;
for (auto e : dec) cout << e << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define DBG cerr << '!' << endl;
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define rep(i,s,g) for(ll (i) = (s);(i) < (g);++i)
#define rrep(i,s,g) for(ll (i) = (s);i >= (g);--(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {for(int W = 0;W < (n);W++)cerr << v[W] << ' ';cerr << endl << endl;}
#define SHOW2d(v,i,j) {for(int aaa = 0;aaa < i;aaa++){for(int bbb = 0;bbb < j;bbb++)cerr << v[aaa][bbb] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(10)
#define INF 1000000000
#define MOD 998244353
typedef long long ll;
typedef pair<ll,ll> P;
set<string> s;
ll ans;
ll dp[222222][3][4][4];
void zentan(string str){
ans++;
//cout << str << endl;
s.insert(str);
REP(i,str.size()-1){
if(str[i] != str[i+1]){
string tmp = str;
REP(j,3){
if(str[i] != (char)('a'+j) && str[i+1] != (char)('a'+j)){
tmp[i] = (char)('a'+j);
tmp[i+1] = (char)('a'+j);
if(s.find(tmp) == s.end()){
zentan(tmp);
}
}
}
}
}
}
int main()
{
string str;cin >> str;
if(str.size() < 5){
zentan(str);
cout << ans << endl;
return 0;
}
dp[1][0][0][0] = 1;
dp[1][0][1][1] = 1;
dp[1][0][2][2] = 1;
ll difff = 0;
ll md = 0;
REP(i,str.size()){
REP(j,3){
REP(k,3){
REP(l,3){
if(j == k)dp[i+1][1][k][(k+l)%3] = (dp[i+1][1][k][(k+l)%3] + dp[i][0][j][l]) % MOD;
else dp[i+1][0][k][(k+l)%3] = (dp[i+1][0][k][(k+l)%3] + dp[i][0][j][l]) % MOD;
dp[i+1][1][k][(k+l)%3] = (dp[i+1][1][k][(k+l)%3] + dp[i][1][j][l]) % MOD;
}
}
}
if(i != str.size() - 1 && str[i] != str[i+1])difff++;
md = (md + (str[i] - 'a')) % 3;
}
REP(i,3)ans = (dp[str.size()][1][i][md] + ans) % MOD;
if(difff == str.size()-1)ans = (ans + 1) % MOD;
if(difff == 0)ans = 1;
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main() {
int n, m, p;
while(cin >> n >> m >> p, n) {
vector<vector<vector<int>>> v(n, vector<vector<int>>(n, vector<int>(n, -1)));
string winner;
int moves;
bool finished = false;
for(int i=0; i<p; ++i) {
int x, y;
cin >> x >> y;
if(finished) continue;
int z;
for(int j=0; j<v[x-1][y-1].size(); ++j) {
if(v[x-1][y-1][j] == -1) {
v[x-1][y-1][j] = i%2; // 0:black 1:white
z = j;
break;
}
}
finished = [i2 = i, n, m, &winner, &moves, &v]() {
int dx[13] = {1, 0, 0, 1, -1, 1, -1, 0, 0, 1, -1, -1, 1},
dy[13] = {0, 1, 0, 1, 1, 0, 0, 1, -1, 1, 1, -1, -1},
dz[13] = {0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1};
for(int i=0; i<n; ++i) {
for(int j=0; j<n; ++j) {
for(int k=0; k<n; ++k) {
for(int l=0; l<13; ++l) {
int cnt = 0;
for(int l2=0; l2<m; ++l2) {
int nx = i + dx[l] * l2,
ny = j + dy[l] * l2,
nz = k + dz[l] * l2;
if(nx < 0 || n <= nx || ny < 0 || n <= ny || nz < 0 || n <= nz || v[nx][ny][nz] == -1) {
cnt = -1;
break;
}
cnt += v[nx][ny][nz];
}
if(cnt == 0) {
winner = "Black";
moves = i2+1;
return true;
} else if(cnt == m) {
winner = "White";
moves = i2+1;
return true;
}
}
}
}
}
return false;
}();
}
if(winner == "") {
cout << "Draw" << endl;
} else {
cout << winner << " " << moves << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &a) {
T w = 1;
a = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') w = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) a = (a * 10) + (ch - '0');
a *= w;
}
template <typename T>
inline void ckmax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void ckmin(T &a, T b) {
a = a < b ? a : b;
}
const long long MAX = 505;
const long long mod = 1e9 + 7;
inline long long add(long long x, long long y) {
return (x + y) >= mod ? (x + y - mod) : (x + y);
}
inline long long Mul(long long x, long long y) {
return (1ll * x * y) >= mod ? (1ll * x * y % mod) : (x * y);
}
inline void Add(long long &x, long long y) {
x = (x + y) >= mod ? (x + y - mod) : (x + y);
}
long long a[MAX][MAX];
long long dp[MAX][MAX][2];
signed main() {
long long n;
read(n);
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j) read(a[i][j]);
for (long long i = 1; i <= n; ++i) dp[i][i][1] = 1;
for (long long len = 2; len <= n; ++len)
for (long long i = 1, j = len; j <= n; i++, j++) {
if (a[i][j])
for (long long k = i; k < j; ++k)
Add(dp[i][j][0], Mul(add(dp[i][k][0], dp[i][k][1]),
add(dp[k + 1][j][0], dp[k + 1][j][1])));
for (long long k = i + 1; k <= j - 1; ++k)
if (a[i][k])
Add(dp[i][j][1], Mul(dp[i][k][0], add(dp[k][j][1], dp[k][j][0])));
}
printf("%lld\n", add(dp[1][n][0], dp[1][n][1]));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k, i;
cin >> n >> k;
string s;
cin >> s;
map<char, int> m;
for (i = 0; i < n; i++) m[s[i]]++;
for (auto i : m)
if (i.second > k) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6 + 10;
const int N = 1e5 + 10;
int pos;
struct TnT {
int sta, ed, num;
TnT() {}
TnT(int sta, int ed, int num) : sta(sta), ed(ed), num(num) {}
bool operator<(const TnT &a) const { return ed - pos > a.ed - pos; }
};
priority_queue<TnT> q;
vector<int> vc[M];
string s[N];
int main() {
int n, k, pp;
scanf("%d", &n);
int Max = 1;
for (int i = 1; i <= n; i++) {
cin >> s[i];
cin >> k;
int len = s[i].size();
for (int j = 0; j < k; j++) {
cin >> pp;
Max = max(Max, pp + len - 1);
vc[pp - 1].push_back(i);
}
}
for (pos = 0; pos < Max; pos++) {
int len = vc[pos].size();
for (int i = 0; i < len; i++) {
int L = s[vc[pos][i]].size();
q.push(TnT(pos, pos + L - 1, vc[pos][i]));
}
if (q.empty())
cout << 'a';
else {
cout << s[q.top().num][pos - q.top().sta];
while (!q.empty()) {
if (q.top().ed == pos)
q.pop();
else
break;
}
}
}
cout << endl;
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <tuple>
#include <algorithm>
using namespace std;
int main() {
string T, P;
cin >> T >> P;
vector<pair<string, uint32_t>> sa;
for (uint32_t i = 0; i < T.length(); i++) {
sa.push_back(make_pair(T.substr(i, T.length()-i), i));
}
sort(sa.begin(), sa.end());
auto itr_lb = lower_bound(sa.begin(), sa.end(), P, [](pair<string, uint32_t> p, string s) {return p.first < s;});
auto itr_ub = upper_bound(sa.begin(), sa.end(), P, [](string s, pair<string, uint32_t> p) {return s < p.first.substr(0, s.length());});
vector<uint32_t> indexes;
for (auto itr = itr_lb; itr != itr_ub; itr++) {
indexes.push_back((*itr).second);
}
sort(indexes.begin(), indexes.end());
for (uint32_t index : indexes) {
cout << index << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> sum;
int main() {
int n, k;
int a[5001];
cin >> n;
cout << "?"
<< " " << 1 << " "
<< "2" << endl;
cin >> k;
sum.push_back(k);
cout << "?"
<< " " << 2 << " "
<< "3" << endl;
cin >> k;
sum.push_back(k);
cout << "?"
<< " " << 1 << " "
<< "3" << endl;
cin >> k;
sum.push_back(k);
a[2] = (sum[1] - sum[2] + sum[0]) / 2;
a[1] = sum[0] - a[2];
a[3] = sum[2] - a[1];
for (int i = 3; i < n; i++) {
cout << "?"
<< " " << i << " " << i + 1 << endl;
cin >> k;
a[i + 1] = k - a[i];
}
cout << "! ";
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
static int min(int a, int b) { return a < b ? a : b; }
int main(void) {
int n, m, x, y, k, i;
long long ts = 0;
scanf("%d %d %d %d %d", &n, &m, &x, &y, &k);
for (i = 0; i < k; ++i) {
int dx, dy, s, lx, ly;
scanf("%d %d", &dx, &dy);
lx = dx < 0 ? 1 : n;
ly = dy < 0 ? 1 : m;
s = min(dx == 0 ? 1000000000 : (lx - x) / dx,
dy == 0 ? 1000000000 : (ly - y) / dy);
x += s * dx;
y += s * dy;
ts += s;
}
printf("%I64d\n", ts);
exit(EXIT_SUCCESS);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long r, c, i, j;
cin >> r >> c;
if (r == c && c == 1) {
cout << "0\n";
return 0;
}
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++)
(c >= r) ? (cout << (i + 1) * (r + j + 1) << " ")
: (cout << (j + 1) * (c + i + 1) << " ");
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5005;
const long long mod = 998244353;
long long n, a[maxn], c[maxn];
long long sum[maxn], dp[maxn][maxn];
long long find(long long x) {
long long l = 1, r = x, res = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (2 * a[mid] <= a[x]) {
res = mid;
l = mid + 1;
} else
r = mid - 1;
}
return res;
}
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
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) {
c[i] = find(i);
}
for (long long i = 1; i <= n; ++i) {
dp[1][i] = 1;
(sum[i] = sum[i - 1] + dp[1][i]) %= mod;
}
for (long long i = 2; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
long long tmp = 0;
(tmp += sum[c[j]]) %= mod;
(tmp += dp[i - 1][j] * (c[j] - i + 2)) %= mod;
(dp[i][j] += tmp) %= mod;
}
for (long long j = 1; j <= n; ++j) {
(sum[j] = sum[j - 1] + dp[i][j]) %= mod;
}
}
long long ans = 0;
for (long long i = 1; i <= n; ++i) ans += dp[n][i];
cout << ans;
return 0;
}
| 6 |
#include<iostream>
#include<cmath>
using namespace std;
typedef long long ll;
int main() {
int q; cin >> q;
for (int i = 0; i < q; i++) {
long a, b; cin >> a >> b;
long r = (long)sqrt(a * b), ans = r * 2;
if (a != b) ans--;
if (a * b <= r * r) ans--;
if (a * b <= r * (r + 1)) ans--;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 3e5 + 5;
const long long mod = 1000000007;
struct Trie {
int ch[26], fth, pos;
bool belong[3];
} trie[max_n];
int tot_trie = 1;
struct Suffix_Automaton {
int len, fth;
int ch[26];
} sam[max_n * 2];
int cnt[4][max_n * 2];
int tot_sam = 1;
void Build(int c, int t) {
int p = trie[trie[t].fth].pos, np = trie[t].pos = ++tot_sam;
sam[np].len = sam[p].len + 1;
for (int i = 0; i < 3; i++)
if (trie[t].belong[i]) cnt[i][np] = 1;
for (; p && !sam[p].ch[c]; p = sam[p].fth) sam[p].ch[c] = np;
if (!p) {
sam[np].fth = 1;
return;
}
int q = sam[p].ch[c];
if (sam[q].len == sam[p].len + 1) {
sam[np].fth = q;
return;
}
int nq = ++tot_sam;
sam[nq] = sam[q];
sam[nq].len = sam[p].len + 1;
sam[q].fth = sam[np].fth = nq;
for (; p && sam[p].ch[c] == q; p = sam[p].fth) sam[p].ch[c] = nq;
}
inline void bfs() {
struct Queue {
int p, c;
};
queue<Queue> q;
for (int &i : trie[0].ch) i = 1;
trie[1].pos = 1;
for (int i = 0; i < 26; i++)
if (trie[1].ch[i]) q.push({trie[1].ch[i], i});
while (!q.empty()) {
int p = q.front().p, c = q.front().c;
q.pop();
Build(c, p);
for (int i = 0; i < 26; i++)
if (trie[p].ch[i]) q.push({trie[p].ch[i], i});
}
}
struct Edge {
int to, next;
} edge[max_n * 2];
int head[max_n * 2];
void dfs(int p) {
for (int i = head[p]; i; i = edge[i].next) {
dfs(edge[i].to);
for (int j = 0; j < 3; j++) cnt[j][p] += cnt[j][edge[i].to];
}
}
char s[max_n];
long long ans[max_n];
signed main() {
int n = 0x3f3f3f3f;
for (int i = 0; i < 3; i++) {
scanf("%s", s + 1);
int len = strlen(s + 1);
n = min(n, len);
int p = 1;
for (int j = 1; j <= len; j++) {
if (trie[p].ch[s[j] - 'a'] == 0) {
trie[p].ch[s[j] - 'a'] = ++tot_trie;
trie[trie[p].ch[s[j] - 'a']].fth = p;
}
p = trie[p].ch[s[j] - 'a'];
trie[p].belong[i] = true;
}
}
bfs();
for (int i = 2, tot = 0; i <= tot_sam; i++)
edge[++tot] = {i, head[sam[i].fth]}, head[sam[i].fth] = tot;
dfs(1);
for (int i = 2; i <= tot_sam; i++) {
long long tmp = 1ll * cnt[0][i] * cnt[1][i] % mod * cnt[2][i] % mod;
ans[sam[i].len] += tmp, ans[sam[i].len] %= mod;
ans[sam[sam[i].fth].len] -= tmp, ans[sam[sam[i].fth].len] += mod,
ans[sam[sam[i].fth].len] %= mod;
}
for (int i = n; i >= 0; i--) ans[i] += ans[i + 1], ans[i] %= mod;
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
list<int> l[205];
int sum[205][200005];
int main() {
int t, n, a, i;
int j;
cin >> t;
while (t--) {
cin >> n;
for (j = 1; j <= 200; j++) {
sum[j][0] = 0;
l[j].clear();
}
for (i = 1; i <= n; i++) {
cin >> a;
for (j = 1; j <= 200; j++) {
sum[j][i] = sum[j][i - 1];
}
sum[a][i]++;
l[a].push_back(i);
}
int ans = 1;
int pi, pj;
int aans = 0;
for (i = 1; i <= 200; i++) {
aans = 0;
if (l[i].size() <= 1) continue;
while (l[i].size() >= 2) {
pi = l[i].front();
pj = l[i].back();
l[i].pop_front();
l[i].pop_back();
aans += 2;
for (int u = 1; u <= 200; u++) {
ans = max(ans, aans + sum[u][pj - 1] - sum[u][pi]);
}
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include<iostream>
#include<vector>
#include<queue>
using namespace std;
using ll = long long;
int main() {
int N, M;
cin >> N >> M;
vector<bool> isReached(N, false), is(N,false);
vector<ll> count(N,0),c(N,0);
vector< vector<int> > graph(N);
queue<int> que;
vector<int> dist(N),d(N);
int s, t;
cin >> s >> t;
s--; t--;
int x, y;
for(int i=0 ; i<M ; i++){
cin >> x >> y;
x--; y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
int now;
que.push(s);
count[0] = 1;
isReached[s] = true;
dist[s] = 0;
while(!que.empty()){
now = que.front();
que.pop();
for(int i=0; i<graph[now].size() ; i++){
if(!isReached[graph[now][i]]){
que.push(graph[now][i]);
isReached[graph[now][i]] = true;
dist[graph[now][i]] = dist[now]+1;
count[dist[graph[now][i]]]++;
}
}
}
que.push(t);
c[0] = 1;
is[t] = true;
d[t]=0;
while(!que.empty()){
now = que.front();
que.pop();
for(int i=0; i<graph[now].size() ; i++){
if(!is[graph[now][i]]){
que.push(graph[now][i]);
is[graph[now][i]] = true;
d[graph[now][i]] = d[now]+1;
c[d[graph[now][i]]]++;
}
}
}
ll ans=0;
for(int i=0; i<= dist[t]-2 ; i++){
ans+= count[i]*c[dist[t]-2-i];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define x first
#define y second
using namespace std;
using f64 = double;
using i64 = long long;
using pii = pair<i64, i64>;
const i64 MOD = 1e9 + 7;
const int N = 1e5 + 5;
vector<pii> g[N], dag[N];
i64 dist[N], in[N], ut[N];
int deg_in[N], deg_ut[N];
bool f[N];
i64 ant;
int n, m, s, t;
static void fix(i64 &x) {
x = x >= MOD ? x - MOD : x; }
static void dijkstra(int s) {
priority_queue<pii> pq;
i64 u, d;
memset(dist, 0x3f, sizeof dist);
pq.emplace(0, s);
dist[s] = 0;
while (!pq.empty()) {
pii top = pq.top(); pq.pop();
tie(d, u) = tie(top.x, top.y);
if (dist[u] == -d)
for (auto v: g[u]) if (dist[v.x] > -(d - v.y)) {
dist[v.x] = -(d - v.y);
pq.emplace(-dist[v.x], v.x); } } }
static void make_dag(int u) {
f[u] = true;
for (auto v: g[u]) if (dist[v.x] == dist[u] - v.y && dist[v.x] < dist[u]) {
dag[v.x].emplace_back(u, v.y); deg_ut[v.x]+= 1;
dag[u].emplace_back(v.x, -v.y); deg_in[u]+= 1;
if (!f[v.x])
make_dag(v.x); } }
static void dp_in(int u) {
for (auto v: dag[u]) if (v.y > 0) {
deg_in[v.x]-= 1;
in[v.x] = (in[v.x] + in[u]) % MOD;
if (!deg_in[v.x])
dp_in(v.x); } }
static void dp_ut(int u) {
for (auto v: dag[u]) if (v.y < 0) {
deg_ut[v.x]-= 1;
ut[v.x] = (ut[v.x] + ut[u]) % MOD;
if (!deg_ut[v.x])
dp_ut(v.x); } }
static void magic() {
i64 cnt, len = dist[t];
for (int u = 1; u <= n; ++u) if (dist[u] == len - dist[u]) { // for nodes
cnt = (in[u] * ut[u]) % MOD;
ant+= cnt * (in[t] - cnt) % MOD; }
for (int u = 1; u <= n; ++u) // for edges
for (auto v: dag[u]) if (v.y > 0 && abs((len - dist[v.x]) - dist[u]) < v.y) {
cnt = (in[u] * ut[v.x]) % MOD;
ant+= cnt * (in[t] - cnt) % MOD; }
ant = ((ant % MOD) + MOD) % MOD; }
int main() {
#ifdef HOME
freopen("arc.in", "r", stdin);
freopen("arc.out", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m >> s >> t;
for (int u, v, c, i = 0; i < m; ++i) {
cin >> u >> v >> c;
g[u].emplace_back(v, c);
g[v].emplace_back(u, c); }
dijkstra(s);
make_dag(t);
in[s] = 1, dp_in(s);
ut[t] = 1, dp_ut(t);
magic();
cout << ant << endl;
return 0; }
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int a[24];
int l1[] = {13, 14, 5, 6, 17, 18, 21, 22};
int l2[] = {15, 16, 7, 8, 19, 20, 23, 24};
int l3[] = {1, 3, 5, 7, 9, 11, 24, 22};
int l4[] = {2, 4, 6, 8, 10, 12, 23, 21};
int l5[] = {3, 4, 17, 19, 10, 9, 16, 14};
int l6[] = {1, 2, 18, 20, 12, 11, 15, 13};
int main() {
int t, i, j, k;
for (i = 0; i < 8; i++) cerr << l1[i] << " ";
cerr << endl;
for (i = 0; i < 8; i++) cerr << l2[(i + 6) % 8] << " ";
cerr << endl;
for (i = 0; i < 24; i++) scanf("%d", &a[i + 1]);
if (a[1] == a[2] && a[2] == a[3] && a[3] == a[4]) {
if (a[9] == a[10] && a[10] == a[11] && a[11] == a[12]) {
for (i = 0; i < 8; i += 2) {
if (a[l1[i]] != a[l1[i + 1]]) break;
if (a[l2[(i + 2) % 8]] != a[l2[(i + 1 + 2) % 8]]) break;
if (a[l1[i]] != a[l2[(i + 1 + 2) % 8]]) break;
}
if (i == 8) {
printf("YES\n");
return 0;
}
for (i = 0; i < 8; i += 2) {
if (a[l1[i]] != a[l1[i + 1]]) break;
if (a[l2[(i + 6) % 8]] != a[l2[(i + 1 + 6) % 8]]) break;
if (a[l1[i]] != a[l2[(i + 1 + 6) % 8]]) break;
}
if (i == 8) {
printf("YES\n");
return 0;
}
}
}
if (a[13] == a[14] && a[14] == a[15] && a[15] == a[16]) {
if (a[17] == a[18] && a[18] == a[19] && a[19] == a[20]) {
for (i = 0; i < 8; i += 2) {
if (a[l3[i]] != a[l3[i + 1]]) break;
if (a[l4[(i + 2) % 8]] != a[l4[(i + 1 + 2) % 8]]) break;
if (a[l3[i]] != a[l4[(i + 1 + 2) % 8]]) break;
}
if (i == 8) {
printf("YES\n");
return 0;
}
for (i = 0; i < 8; i += 2) {
if (a[l3[i]] != a[l3[i + 1]]) break;
if (a[l4[(i + 6) % 8]] != a[l4[(i + 1 + 6) % 8]]) break;
if (a[l3[i]] != a[l4[(i + 1 + 6) % 8]]) break;
}
if (i == 8) {
printf("YES\n");
return 0;
}
}
}
if (a[5] == a[6] && a[6] == a[7] && a[7] == a[8]) {
if (a[21] == a[22] && a[22] == a[23] && a[23] == a[24]) {
for (i = 0; i < 8; i += 2) {
if (a[l5[i]] != a[l5[i + 1]]) break;
if (a[l6[(i + 2) % 8]] != a[l6[(i + 1 + 2) % 8]]) break;
if (a[l5[i]] != a[l6[(i + 1 + 2) % 8]]) break;
}
if (i == 8) {
printf("YES\n");
return 0;
}
for (i = 0; i < 8; i += 2) {
if (a[l5[i]] != a[l5[i + 1]]) break;
if (a[l6[(i + 6) % 8]] != a[l6[(i + 1 + 6) % 8]]) break;
if (a[l5[i]] != a[l6[(i + 1 + 6) % 8]]) break;
}
if (i == 8) {
printf("YES\n");
return 0;
}
}
}
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
;
double nr1;
cin >> nr1;
double r1, fr1 = 0;
for (double i = 0; i < nr1; i++) {
cin >> r1;
fr1 = (max(fr1, r1));
}
double nden1;
cin >> nden1;
double den1, fden1 = 0;
for (double i = 0; i < nden1; i++) {
cin >> den1;
fden1 = max(fden1, den1);
}
double nden2;
cin >> nden2;
double den2, fden2 = 111313131;
for (double i = 0; i < nden2; i++) {
cin >> den2;
fden2 = min(fden2, den2);
}
double r2 = 0.0;
double a, b;
cin >> a >> b;
cout.precision(10);
r2 = (sqrt((fden1 * fr1 * fr1 * b) / ((fden1 * b) + (fden2 * a))));
cout << r2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200009];
long long M = (long long)998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
vector<long long> v;
for (int i = 1; i <= n; i++) {
v.push_back((1LL * i * (n - i + 1) * arr[i]));
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
v[i] %= M;
}
vector<long long> b;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
b.push_back(x);
}
sort(b.begin(), b.end());
for (int i = 0; i < n; i++) {
b[i] %= M;
}
long long res = 0;
for (int i = 0; i < n; i++) {
res = (res + (v[n - i - 1] * b[i]) % M) % M;
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
char s[20];
int main() {
scanf("%s", s);
int i = 0;
if (s[i] == '9') i++;
while (s[i] != '\0') {
if (s[i] >= '5') {
s[i] = 9 - (s[i] - '0') + '0';
}
i++;
}
printf("%s", s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932384626433832795;
const long long INF = 1LL << 62;
const long long MINF = -1LL << 62;
template <typename T>
T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> a >> b;
long long res = 1;
long long mod = 998244353;
for (int i = 0; i < a + b; ++i) res = res * 2 % mod;
cout << res << "\n";
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef long long ll;
int main(){
ll L,R;
cin>>L>>R;
if(R-L>=2019) cout<<0;
else{
ll m=2018;
for(ll i=L;i<=R;i++)for(ll j=i+1;j<=R;j++) m=min(m,i*j%2019);
cout<<m;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
int n, a[MAX], L1[MAX], L2[MAX], R1[MAX], R2[MAX];
long long tree[(MAX << 2)], H[MAX];
int l, r, val, lazy[(MAX << 2)], mn[(MAX << 2)], mx[(MAX << 2)];
void push(int low, int high, int pos) {
if (lazy[pos]) {
tree[pos] = (high - low + 1) * (long long)lazy[pos];
mx[pos] = mn[pos] = lazy[pos];
if (low != high) {
lazy[(pos << 1)] = lazy[pos];
lazy[(pos << 1) + 1] = lazy[pos];
}
lazy[pos] = 0;
}
}
void upd(int low, int high, int pos) {
push(low, high, pos);
if (l > high || r < low || mn[pos] >= val) {
return;
}
if (l <= low && r >= high && mx[pos] <= val) {
tree[pos] = (high - low + 1) * (long long)val;
mx[pos] = mn[pos] = val;
if (low != high) {
lazy[(pos << 1)] = val;
lazy[(pos << 1) + 1] = val;
}
return;
}
int mid = ((low + high) >> 1);
upd(low, mid, (pos << 1));
upd(mid + 1, high, (pos << 1) + 1);
mx[pos] = max(mx[(pos << 1)], mx[(pos << 1) + 1]);
mn[pos] = min(mn[(pos << 1)], mn[(pos << 1) + 1]);
tree[pos] = tree[(pos << 1)] + tree[(pos << 1) + 1];
}
void play(int j, int i) {
if (!L1[j])
L1[j] = i;
else if (!L2[j])
L2[j] = i;
R2[j] = R1[j];
R1[j] = i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int j = 1; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
play(j, i);
if (j * j != a[i]) {
play(a[i] / j, i);
}
}
}
}
for (int i = 1; i <= n; ++i) {
l = i;
r = i;
val = i;
upd(1, n, 1);
}
for (int i = 200000; i >= 0; --i) {
push(1, n, 1);
H[i] = (n + 1) * (long long)(n)-tree[1];
if (L1[i] != R1[i]) {
l = 1;
r = L1[i];
val = R2[i];
upd(1, n, 1);
l = L1[i] + 1;
r = L2[i];
val = R1[i];
upd(1, n, 1);
l = L2[i] + 1;
r = n;
val = n + 1;
upd(1, n, 1);
}
}
long long ans = 0;
for (int i = 1; i <= 200000; ++i) {
ans += (H[i] - H[i - 1]) * (long long)i;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <typename T, typename _T>
inline bool chk_min(T &x, const _T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T, typename _T>
inline bool chk_max(T &x, const _T y) {
return x < y ? x = y, 1 : 0;
}
const int N = (int)1e5 + 5;
struct ConvexHull {
int l, r;
long long X[N], Y[N];
ConvexHull() { clear(); }
void clear() { l = 1, r = 0; }
void push_back(long long x, long long y) {
while (l < r &&
!((Y[r] - Y[r - 1]) * (x - X[r]) > (y - Y[r]) * (X[r] - X[r - 1])))
r--;
X[++r] = x, Y[r] = y;
}
} CH;
struct node {
long long x, y;
bool operator<(const node &_) const {
if (x != _.x)
return x < _.x;
else
return y > _.y;
}
} nd[N];
int n;
int main() {
scanf("%d", &n);
for (int i = (1), iEND = (n); i <= iEND; ++i) {
int x, y;
scanf("%d%d", &x, &y);
nd[i] = (node){x, y - 1ll * x * x};
}
std::sort(nd + 1, nd + 1 + n);
for (int i = (1), iEND = (n); i <= iEND; ++i) {
if (i != 1 && nd[i].x == nd[i - 1].x) continue;
CH.push_back(nd[i].x, nd[i].y);
}
printf("%d\n", CH.r - CH.l);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
struct Pai {
int id, as, b;
} ans[maxn];
int a[maxn], N;
bool cmpb(Pai x, Pai y) { return x.b > y.b; }
bool cmpid(Pai x, Pai y) { return x.id < y.id; }
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &a[i]);
sort(a, a + N);
for (int i = 0; i < N; i++) {
scanf("%d", &ans[i].b);
ans[i].id = i;
}
sort(ans, ans + N, cmpb);
for (int i = 0; i < N; i++) ans[i].as = a[i];
sort(ans, ans + N, cmpid);
for (int i = 0; i < N; i++) printf("%d ", ans[i].as);
return 0;
}
| 3 |
#include<algorithm>
#include<iostream>
#include<stack>
#include<vector>
using namespace std;
int main(){
//freopen("ALDS1_3_D.txt","r",stdin);
stack<int>S1;
stack<pair<int,int> >S2;
char ch;
int sum=0;
for(int i=0;cin>>ch;i++){
if(ch=='\\')S1.push(i);
else if(ch=='/'&&S1.size()){
int j=S1.top();
S1.pop();
int a=i-j;
sum+=a;
while(S2.size()&&S2.top().first>j){
a+=S2.top().second;
S2.pop();
}
S2.push(make_pair(j,a));
}
}
vector<int>ans;
while(S2.size()){
ans.push_back(S2.top().second);
S2.pop();
}
reverse(ans.begin(),ans.end());
int size=ans.size();
printf("%i\n%i",sum,size);
for(int i=0;i<size;i++)printf(" %i",ans[i]);
putchar('\n');
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> ma, v[maxn], r;
int n, k, m, a;
int vis[maxn];
int cnt, ff;
void dfs(int x) {
if (vis[x] == 2) return;
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (vis[to] == 1) {
cout << -1 << endl;
exit(0);
}
dfs(to);
}
vis[x] = 2;
r.push_back(x);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < k; i++) {
cin >> a;
ma.push_back(a);
}
for (int i = 1; i <= n; i++) {
cin >> m;
for (int j = 0; j < m; j++) {
cin >> a;
v[i].push_back(a);
}
}
for (int i = 0; i < ma.size(); i++) {
dfs(ma[i]);
}
int l = r.size();
cout << l << endl;
for (int i = 0; i < l - 1; i++) cout << r[i] << ' ';
cout << r[l - 1] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, p;
bool operator<(const node &a) const {
if (l == a.l) return p < a.p;
return l < a.l;
}
} N[100001][4];
set<node> S[4];
bool dfs(set<node> L[4]) {
if (L[0].size() <= 1) return 1;
set<node> R[4];
set<node>::iterator it[4], t;
int m[4];
for (int i = 0; i < 4; i++)
it[i] = L[i].begin(), m[i] = (*it[i]).r, it[i]++, R[i].clear();
for (int i = 1; i < L[0].size(); i++)
for (int j = 0; j < 4; j++) {
if ((*it[j]).l >= m[j]) {
for (t = L[j].begin(); t != it[j];) {
int p = (*t).p;
t++;
for (int k = 0; k < 4; k++) R[k].insert(N[p][k]), L[k].erase(N[p][k]);
}
return dfs(L) && dfs(R);
}
m[j] = max(m[j], (*it[j]).r), it[j]++;
}
return 0;
}
int main() {
int a, i, j, x, y, n, m;
cin >> a;
for (i = 1; i <= a; i++) {
scanf("%d%d%d%d", &x, &y, &n, &m),
N[i][0] = {x, n, i}, N[i][1] = {-n, -x, i}, N[i][2] = {y, m, i},
N[i][3] = {-m, -y, i};
for (j = 0; j < 4; j++) S[j].insert(N[i][j]);
}
if (dfs(S))
puts("YES");
else
puts("NO");
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.