solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct FastIO{
FastIO(){
cin.tie(0);
ios::sync_with_stdio(0);
}
}fastio_beet;
//INSERT ABOVE HERE
const int MAX = 5e5+100;
int nxt[27][MAX+1];
int dbl[21][MAX+1];
signed main(){
string s;
cin>>s;
for(int i=0;i<=MAX;i++)
for(int j=0;j<=26;j++) nxt[j][i]=MAX;
int n=s.size();
for(int i=n-1;i>=0;i--){
chmin(nxt[s[i]-'a'][i],i+1);
for(int j=0;j<26;j++)
chmin(nxt[j+1][i],nxt[j][nxt[j][i]]);
for(int j=0;j<26;j++){
chmin(nxt[j][i],nxt[j][nxt[26][i]]);
chmin(nxt[j+1][i],nxt[j][nxt[j][i]]);
}
}
for(int i=0;i<=MAX;i++)
dbl[0][i]=nxt[26][i];
for(int k=0;k<20;k++)
for(int i=0;i<=MAX;i++)
dbl[k+1][i]=dbl[k][dbl[k][i]];
int q;
cin>>q;
for(int i=0;i<q;i++){
int l,r;
cin>>l>>r;
l--;
int d=20;
while(d>=0){
if(dbl[d][l]<=r) l=dbl[d][l];
d--;
}
cout<<(l==r?"Yes":"No")<<"\n";
}
cout<<flush;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Max_N = 1e3;
int n, fir, tot, lst[Max_N + 5], bln[Max_N + 5], nxt[Max_N + 5], vis[Max_N + 5],
ans[Max_N + 5][Max_N + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &nxt[i]);
for (int i = 1; i <= n; i++) lst[nxt[i]] = i;
for (int i = 1; i <= n && !fir; i++)
if (lst[i] != i) fir = i;
if (!fir) {
printf("%d\n", n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) putchar('.');
puts("");
}
return 0;
}
for (int i = 1; i <= n; i++) nxt[lst[i]] = i;
for (int i = 1; i <= n; i++)
if (!vis[i] && lst[i] != i) {
int x = nxt[i];
vis[x] = 1;
if (i ^ fir) ++tot, ans[tot][fir] = ans[tot][x] = 1;
for (x = nxt[x]; !vis[x]; x = nxt[x]) {
++tot;
vis[x] = 1;
if (x < lst[x])
ans[tot][x] = ans[tot][lst[x]] = 2;
else
ans[tot][x] = ans[tot][lst[x]] = 1;
}
if (fir != i) ans[tot][fir] = 2;
}
printf("%d\n", n - 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
putchar(ans[i][j] ? (ans[i][j] == 2 ? '\\' : '/') : '.');
puts("");
}
return 0;
}
| 5 |
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int a,b,c,d;
cin >> a >> b >> c >> d;
if((a==b&&c==d)||(a==c&&b==d)||(a==d&&b==c)){
cout << "yes" << endl;
}else{
cout << "no" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e3 + 5, M = 1e9 + 7;
long long a[N];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n, m = 0;
cin >> n;
for (long long i = 1; i <= n; i++)
cin >> a[i], m = max(m, a[i]), a[i] ^= a[i - 1];
for (long long i = 1; i <= n; i++)
for (long long j = i + 1; j <= n; j++) m = max(m, a[j] ^ a[i - 1]);
cout << m;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
int n, k;
char s[4][410];
int sx, sy;
queue<pair<int, int> > Q;
int dp[100][4][400];
void solve() {
for (int i = 0; i < 3; i++)
for (int j = 0; j < n; j++)
if (s[i][j] == 's') {
sx = i, sy = j;
break;
}
s[sx][sy] = '.';
for (int i = 0; i < 3; i++)
for (int j = n; j < 2 * n; j++) s[i][j] = '.';
memset(dp, 0, sizeof(dp));
dp[0][sx][sy] = 1;
for (int t = 1; t <= n / 2 + 1; t++) {
for (int x = 0; x < 3; x++)
for (int y = 0; y < 2 * n; y++) {
if (!dp[t - 1][x][y]) continue;
if (s[x][y + 1] != '.') continue;
if (y + 3 < 2 * n && s[x][y + 2] == '.' && s[x][y + 1] == '.' &&
s[x][y] == '.' && s[x][y + 3] == '.')
dp[t][x][y + 3] = 1;
if (y + 3 < 2 * n && s[x][y] == '.' && x - 1 >= 0 &&
s[x - 1][y + 1] == '.' && s[x - 1][y + 2] == '.' &&
s[x - 1][y + 3] == '.')
dp[t][x - 1][y + 3] = 1;
if (y + 3 < 2 * n && s[x][y] == '.' && x + 1 < 3 &&
s[x + 1][y + 1] == '.' && s[x + 1][y + 2] == '.' &&
s[x + 1][y + 3] == '.')
dp[t][x + 1][y + 3] = 1;
if (y + 3 < 2 * n && s[x][y] == '.' && s[x][y + 1] == '.' &&
s[x][y + 2] == '.' && s[x][y + 3] == '.')
dp[t][x][y + 3] = 1;
}
}
int ok = 0;
for (int t = 1; t <= n / 2 + 1; t++) {
for (int x = 0; x < 2; x++) {
for (int y = n; y < 2 * n; y++) {
if (dp[t][x][y] && s[x][y] == '.') {
puts("YES");
ok = 1;
break;
}
}
if (ok) break;
}
if (ok) break;
}
if (!ok) puts("NO");
return;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d %d", &n, &k);
for (int i = 0; i < 3; i++) {
scanf("%s", s[i]);
}
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, dl, nv, l, r, z, t, ves, ans;
string s, sn;
map<pair<long long, long long>, long long> a;
char el;
int main() {
cin >> z;
for (int i = 1; i <= z; i++) {
cin >> t;
if (t == 1) {
cin >> l >> r >> ves;
while (l != r) {
if (l > r) {
nv = l / 2;
a[make_pair(nv, l)] += ves;
l = l / 2;
} else {
nv = r / 2;
a[make_pair(nv, r)] += ves;
r = r / 2;
}
}
} else {
cin >> l >> r;
ans = 0;
while (l != r) {
if (l > r) {
nv = l / 2;
ans = ans + a[make_pair(nv, l)];
l = l / 2;
} else {
nv = r / 2;
ans = ans + a[make_pair(nv, r)];
r = r / 2;
}
}
cout << ans << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void Boost() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
Boost();
int a, b, n;
cin >> a >> b >> n;
for (int i = 0; i <= 9; ++i) {
int x = a * 10 + i;
if (x % b == 0) {
cout << a << i;
for (int j = 0; j < n - 1; ++j) cout << 0;
return 0;
}
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1E-6;
const int MOD = 1000000007;
const int LEN = 2010;
int dp[LEN][1 << 12], n, m, num[LEN];
void debug() {
for (int j = 0; j <= n; j++) {
for (int i = 0; i <= (1 << (m - 1)); i++) cout << dp[j][i] << ' ';
cout << endl;
}
cout << endl;
}
int main() {
while (cin >> n >> m) {
for (int i = 0; i < n; i++) cin >> num[i];
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << (m - 1)); j++) {
if (num[i] == 0) {
dp[i + 1][j + 1] = (dp[i + 1][j + 1] + dp[i][j]) % MOD;
if (j & 1)
dp[i + 1][2] = (dp[i + 1][2] + dp[i][j]) % MOD;
else {
if (j + 2 >= (1 << (m - 1)))
dp[i + 1][1 << (m - 1)] =
(dp[i + 1][1 << (m - 1)] + dp[i][j]) % MOD;
else
dp[i + 1][j + 2] = (dp[i + 1][j + 2] + dp[i][j]) % MOD;
}
} else if (num[i] == 2) {
dp[i + 1][j + 1] = (dp[i + 1][j + 1] + dp[i][j]) % MOD;
} else {
if (j & 1)
dp[i + 1][2] = (dp[i + 1][2] + dp[i][j]) % MOD;
else {
if (j + 2 >= (1 << (m - 1)))
dp[i + 1][1 << (m - 1)] =
(dp[i + 1][1 << (m - 1)] + dp[i][j]) % MOD;
else
dp[i + 1][j + 2] = (dp[i + 1][j + 2] + dp[i][j]) % MOD;
}
}
}
if (num[i] != 0)
dp[i + 1][1 << (m - 1)] =
(dp[i + 1][1 << (m - 1)] + dp[i][(1 << (m - 1))]) % MOD;
else
dp[i + 1][1 << (m - 1)] =
(dp[i + 1][1 << (m - 1)] + dp[i][(1 << (m - 1))] * 2 % MOD) % MOD;
}
cout << dp[n][1 << (m - 1)] << endl;
}
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int D,N,M;
while(cin>>D,D)
{
cin >> N >> M;
vector<int> v;
v.push_back(0);
while(--N)
{
int d;
cin >> d;
v.push_back(d);
}
v.push_back(D);
sort(v.begin(), v.end());
int a = 0;
while(M--)
{
int k;
cin >> k;
vector<int>::iterator it;
it = upper_bound(v.begin(), v.end(), k);
a += min(*it-k, k-*(it-1));
}
cout << a << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 256;
int cnt[N];
string s, t;
bool dfs(string& s, int pos, bool large) {
if (pos == t.length()) return large || ::s.length() > t.length();
if (large == false) {
if (cnt[t[pos]]) {
cnt[t[pos]]--;
s += t[pos];
if (!dfs(s, pos + 1, 0)) {
s.erase(s.end() - 1);
cnt[t[pos]]++;
for (char c = t[pos] + 1; c <= 'z'; c++) {
if (cnt[c] == 0) continue;
cnt[c]--;
s += c;
return dfs(s, pos + 1, 1);
}
return false;
} else {
return true;
}
} else {
for (char c = t[pos] + 1; c <= 'z'; c++) {
if (cnt[c] == 0) continue;
cnt[c]--;
s += c;
return dfs(s, pos + 1, 1);
}
return false;
}
} else {
for (char c = 'a'; c <= 'z'; c++) {
if (cnt[c] == 0) continue;
cnt[c]--;
s += c;
return dfs(s, pos + 1, 1);
}
return true;
}
}
int main() {
while (cin >> s >> t) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < s.length(); i++) {
cnt[s[i]]++;
}
string ans;
if (dfs(ans, 0, false)) {
for (int i = 'a'; i <= 'z'; i++) {
for (int j = 0; j < cnt[i]; j++) {
ans += i;
}
}
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<long long int> v(n);
if (n == 1) {
cout << "no" << endl;
return 0;
}
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
vector<pair<long long int, long long int> > p;
for (long long int i = 0; i < (n - 1); i++) {
if (v[i] < v[i + 1]) {
p.push_back(make_pair(v[i], v[i + 1]));
} else {
p.push_back(make_pair(v[i + 1], v[i]));
}
}
for (long long int i = 0; i < p.size() - 1; i++) {
for (long long int j = (i + 1); j < p.size(); j++) {
long long int a1 = p[i].first;
long long int b1 = p[i].second;
long long int a2 = p[j].first;
long long int b2 = p[j].second;
if (a1 < a2) {
if (a2 < b1 && b1 < b2 && a1 < a2 && a2 < b1) {
cout << "yes" << endl;
return 0;
}
} else {
if (a2 < a1 && a1 < b2 && a1 < b2 && b2 < b1) {
cout << "yes" << endl;
return 0;
}
}
}
}
cout << "no" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
const int MD = 998244353;
void add(int& a, int b) {
a += b;
if (a >= MD) a -= MD;
}
void sub(int& a, int b) {
a -= b;
if (a < 0) a += MD;
}
int mod_mult(long long a, long long b) { return (a * b) % MD; }
int h[MX];
int fact[MX];
int inv_fact[MX];
int exp(int a, int b) {
int res = 1;
while (b) {
if (b % 2 == 1) res = mod_mult(res, a);
a = mod_mult(a, a);
b /= 2;
}
return res;
}
int C(int n, int k) {
int tmp = fact[n];
tmp = mod_mult(tmp, inv_fact[k]);
tmp = mod_mult(tmp, inv_fact[n - k]);
return tmp;
}
int f(int x) {
int tmp = exp(2, x);
if (x % 2 == 0) {
sub(tmp, C(x, x / 2));
}
tmp = mod_mult(tmp, inv_fact[2]);
return tmp;
}
int main() {
fact[0] = 1;
for (int i = 1; i < MX; i++) {
fact[i] = mod_mult(fact[i - 1], i);
}
inv_fact[MX - 1] = exp(fact[MX - 1], MD - 2);
for (int i = MX - 2; i >= 0; i--) {
inv_fact[i] = mod_mult(inv_fact[i + 1], i + 1);
}
int n, k;
ignore = scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
ignore = scanf("%d", h + i);
}
int mult_at_end = 1;
int B = 0;
for (int i = 0; i < n; i++) {
if (h[i] == h[(i + 1) % n]) {
mult_at_end = mod_mult(mult_at_end, k);
} else {
B++;
}
}
int ans = 0;
for (int c = 0; c <= B; c++) {
int tmp = exp(k - 2, c);
tmp = mod_mult(tmp, C(B, c));
tmp = mod_mult(tmp, f(B - c));
add(ans, tmp);
}
ans = mod_mult(ans, mult_at_end);
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 3000 + 3;
int a[maxn];
int b[maxn];
std::bitset<maxn> C[maxn];
int main() {
std::vector<std::pair<int, std::pair<int, int> > > Edge;
int n;
std::cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
}
for (int i = 1; i <= n - 1; i++) {
for (int j = i + 1; j <= n; j++) {
Edge.push_back(std::make_pair(
(a[i] - a[j]) * (a[i] - a[j]) + (b[i] - b[j]) * (b[i] - b[j]),
std::make_pair(i, j)));
}
}
std::sort((Edge).begin(), (Edge).end());
int m = Edge.size();
for (int i = m - 1; i >= 0; i--) {
int x = Edge[i].second.first;
int y = Edge[i].second.second;
if ((C[x] & C[y]).any()) {
printf("%0.10lf\n", sqrt(Edge[i].first + 0.0) / 2);
return 0;
}
C[x].set(y);
C[y].set(x);
}
return 0;
}
| 5 |
#include <iostream>
#include <string>
#define MAX 10
#define INF 1 << 29
using namespace std;
int cost[MAX][MAX];
void warshall_floyd() {
for (int k = 0; k < MAX; k++) {
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < MAX; j++) {
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j]);
}
}
}
}
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) return 0;
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < MAX; j++) {
if (i == j) cost[i][j] = 0;
else cost[i][j] = INF;
}
}
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
cost[a][b] = c;
cost[b][a] = c;
}
warshall_floyd();
int ans = INF;
int town = -1;
for (int i = 0; i < MAX; i++) {
int res = 0;
for (int j = 0; j < MAX; j++) {
if (cost[i][j] == INF) continue;
res += cost[i][j];
}
if (res > 0) {
if (res < ans) {
ans = res;
town = i;
}
}
}
cout << town << ' ' << ans << endl;
}
} | 0 |
#include<cstdio>
typedef long long LL;
int N,i,j,x,A[200000],here[200000],town[200000];LL K;
int main(void)
{
i=scanf("%d %lld",&N,&K);
for(i=0;i<N;i++)here[i]=-scanf("%d",&A[i]);
for(i=0,j=0;;i=A[i]-1,j++)if(here[i]<0)here[i]=j,town[j]=i;else{x=here[i];break;}
if(K>=j)K=(K-x)%(x-j)+x;
return printf("%d\n",town[K]+1),0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v[105];
pair<pair<int, int>, double> edge[105];
void dfs(int first, int f, double d) {
double ti = 2.0 / (v[first].size());
double now = fmod(d + ti, 2);
for (auto it : v[first]) {
if (it.first != f) {
dfs(it.first, first, fmod(now + 1, 2));
if (edge[it.second].first.first != first)
swap(edge[it.second].first.first, edge[it.second].first.second);
edge[it.second].second = now;
now = fmod(now + ti, 2);
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int first, second;
scanf("%d %d", &first, &second);
v[first].push_back(make_pair(second, i));
v[second].push_back(make_pair(first, i));
edge[i] = make_pair(make_pair(first, second), 0);
}
for (int i = 1; i < n; i++) {
if (v[i].size() == 1) {
dfs(i, 0, 0);
break;
}
}
printf("%d\n", n - 1);
for (int i = 1; i < n; i++) {
if (edge[i].second >= 1) {
printf("1 %d %d %d %.12lf\n", i, edge[i].first.first,
edge[i].first.second, 2 - edge[i].second);
} else {
printf("1 %d %d %d %.12lf\n", i, edge[i].first.second,
edge[i].first.first, 1 - edge[i].second);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int N;
cin >> N;
cout << "?";
for (int i = 1; i <= N; i++) cout << " " << i;
cout << endl;
string s;
cin >> s;
int l = 1;
int r = N+1;
while (r - l > 1) {
int c = (l+r)/2;
cout << "?";
for (int i = c; i <= c+N-1; i++) cout << " " << i;
cout << endl;
string t;
cin >> t;
if (s == t) l = c;
else r = c;
}
vector<char> ans(2*N+1);
if (s == "Red") {
ans[l] = 'R';
ans[l+N] = 'B';
}else {
ans[l] = 'B';
ans[l+N] = 'R';
}
for (int i = 1; i <= l-1; i++) {
cout << "?";
cout << " " << i;
for (int j = l+1; j <= l+N-1; j++) cout << " " << j;
cout << endl;
string t;
cin >> t;
if (t == "Red") ans[i] = 'R';
else ans[i] = 'B';
}
for (int i = l+N+1; i <= 2*N; i++) {
cout << "?";
cout << " " << i;
for (int j = l+1; j <= l+N-1; j++) cout << " " << j;
cout << endl;
string t;
cin >> t;
if (t == "Red") ans[i] = 'R';
else ans[i] = 'B';
}
for (int i = l+1; i <= l+N-1; i++) {
cout << "?";
cout << " " << i;
for (int j = 1; j <= l-1; j++) cout << " " << j;
for (int j = l+N+1; j <= 2*N; j++) cout << " " << j;
cout << endl;
string t;
cin >> t;
if (t == "Red") ans[i] = 'R';
else ans[i] = 'B';
}
cout << "! ";
for (int i = 1; i <= 2*N; i++) cout << ans[i];
cout << endl;
return 0;
} | 0 |
/* #region header */
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
// types
using ll = long long;
using ull = unsigned long long;
using ld = long double;
typedef pair<ll, ll> Pl;
typedef pair<int, int> Pi;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<char> vc;
template <typename T>
using mat = vector<vector<T>>;
typedef vector<vector<int>> vvi;
typedef vector<vector<long long>> vvl;
typedef vector<vector<char>> vvc;
// abreviations
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep_(i, a_, b_, a, b, ...) for (ll i = (a), max_i = (b); i < max_i; i++)
#define rep(i, ...) rep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define rrep_(i, a_, b_, a, b, ...) \
for (ll i = (b - 1), min_i = (a); i >= min_i; i--)
#define rrep(i, ...) rrep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define srep(i, a, b, c) for (ll i = (a), max_i = (b); i < max_i; i += c)
#define SZ(x) ((int)(x).size())
#define pb(x) push_back(x)
#define eb(x) emplace_back(x)
#define mp make_pair
//入出力
#define print(x) cout << x << endl
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (auto& e : v) cout << e << " ";
cout << endl;
return os;
}
void scan(int& a) { cin >> a; }
void scan(long long& a) { cin >> a; }
void scan(char& a) { cin >> a; }
void scan(double& a) { cin >> a; }
void scan(string& a) { cin >> a; }
template <class T>
void scan(vector<T>& a) {
for (auto& i : a) scan(i);
}
#define vsum(x) accumulate(all(x), 0LL)
#define vmax(a) *max_element(all(a))
#define vmin(a) *min_element(all(a))
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
// functions
// gcd(0, x) fails.
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T>
T mypow(T x, ll n) {
T ret = 1;
while (n > 0) {
if (n & 1) (ret *= x);
(x *= x);
n >>= 1;
}
return ret;
}
ll modpow(ll x, ll n, const ll mod) {
ll ret = 1;
while (n > 0) {
if (n & 1) (ret *= x);
(x *= x);
n >>= 1;
x %= mod;
ret %= mod;
}
return ret;
}
uint64_t my_rand(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 13);
x = x ^ (x >> 7);
return x = x ^ (x << 17);
}
int popcnt(ull x) { return __builtin_popcountll(x); }
template <typename T>
vector<int> IOTA(vector<T> a) {
int n = a.size();
vector<int> id(n);
iota(all(id), 0);
sort(all(id), [&](int i, int j) { return a[i] < a[j]; });
return id;
}
struct Timer {
clock_t start_time;
void start() { start_time = clock(); }
int lap() {
// return x ms.
return (clock() - start_time) * 1000 / CLOCKS_PER_SEC;
}
};
/* #endregion*/
// constant
#define inf 1000000000ll
#define INF 4000000004000000000LL
#define mod 998244353ll
#define endl '\n'
const long double eps = 0.000000000000001;
const long double PI = 3.141592653589793;
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << setprecision(30) << fixed;
ll n, m;
cin >> n >> m;
vl a(n), b(m);
scan(a);
scan(b);
if (n == 1) {
rep(i, m) { cout << a[0] + b[i] << ' '; }
cout << endl;
return 0;
}
vl diff(n - 1);
rep(i, n - 1) { diff[i] = abs(a[i + 1] - a[i]); }
ll g = diff[0];
rep(i, n - 1) {
if (diff[i] != 0) g = gcd(diff[i], g);
}
rep(i, m) { cout << gcd(a[0] + b[i], g) << ' '; }
cout << endl;
} | 1 |
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<set>
using namespace std;
char A[310000];
char B[310000];
int p[310000];
int q[310000];
int bit[310000];
set<int>zero;
set<int>two;
set<int>bb;
int sum(int a,int b){
if(a)return sum(0,b)-sum(0,a-1);
int ret=0;
for(;b>=0;b=(b&(b+1))-1)ret+=bit[b];
return ret;
}
void add(int a,int b){
for(;a<310000;a|=a+1)bit[a]+=b;
}
char in[2];
int main(){
int a;
scanf("%d",&a);
scanf("%s%s",A,B);
int as=strlen(A);
int bs=strlen(B);
two.insert(-1);
zero.insert(-1);
for(int i=0;i<as;i++){
p[i]=A[as-1-i]-'0';
}
for(int i=0;i<bs;i++){
q[i]=B[bs-1-i]-'0';
}
int sz=max(as,bs)+1;
for(int i=0;i<sz;i++){
if(p[i]+q[i]==2)two.insert(i);
if(p[i]+q[i]==0)zero.insert(i);
if(q[i])bb.insert(i);
if(p[i])add(i,1);
}
for(int i=0;i<a;i++){
scanf("%s",in);
if(in[0]=='Q'){
int at=*(bb.rbegin());
int val=sum(at,sz);
int ret=val+at;
if(p[at]==0){
int nt=*(--(two.lower_bound(at)));
int nz=*(--(zero.lower_bound(at)));
// printf("%d %d\n",nt,nz);
if(nt>nz){
ret++;
}
}
printf("%d\n",ret);
}else if(in[0]=='A'){
int t;scanf("%d",&t);
if(p[t]==0){
if(q[t]+p[t]==0)zero.erase(t);
p[t]=1;
if(q[t]+p[t]==2)two.insert(t);
add(t,1);
}else{
if(q[t]+p[t]==2)two.erase(t);
p[t]=0;
if(q[t]+p[t]==0)zero.insert(t);
add(t,-1);
}
}else{
int t;scanf("%d",&t);
if(q[t]==0){
if(q[t]+p[t]==0)zero.erase(t);
q[t]=1;
if(q[t]+p[t]==2)two.insert(t);
bb.insert(t);
}else{
if(q[t]+p[t]==2)two.erase(t);
q[t]=0;
if(q[t]+p[t]==0)zero.insert(t);
bb.erase(t);
}
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5, lg = 20;
long long cnt[maxn][lg], c[maxn], mod = 1e9 + 7;
int par[maxn][lg], h[maxn], p[maxn];
vector<int> adj[maxn], nei[maxn];
bool mark[maxn];
void dfs(int v) {
mark[v] = true;
for (int u : adj[v]) {
if (!mark[u]) {
h[u] = h[v] + 1;
par[u][0] = v;
dfs(u);
} else if (h[u] < h[v] && u != par[v][0]) {
int x = v;
c[u] = 2;
while (x != u) {
p[x] = u;
x = par[x][0];
}
}
}
}
void dfs2(int v) {
mark[v] = true;
for (int u : nei[v]) {
if (!mark[u]) {
par[u][0] = v;
cnt[u][0] = c[u];
h[u] = h[v] + 1;
for (int i = 1; i < lg; i++) {
par[u][i] = par[par[u][i - 1]][i - 1];
cnt[u][i] = cnt[u][i - 1] * cnt[par[u][i - 1]][i - 1] % mod;
}
dfs2(u);
}
}
}
pair<long long, int> get(int x, int he) {
long long val = 1;
for (int i = 0; i < lg; i++) {
if (he & (1 << i)) {
val = val * cnt[x][i] % mod;
x = par[x][i];
}
}
return {x, val};
}
int lca(int x, int y) {
if (h[x] < h[y]) {
swap(x, y);
}
x = get(x, h[x] - h[y]).first;
for (int i = lg - 1; i >= 0; i--) {
if (par[x][i] != par[y][i]) {
x = par[x][i];
y = par[y][i];
}
}
if (x == y) {
return x;
}
return par[x][0];
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 0; i < n; i++) {
fill(cnt[i], cnt[i] + lg, 1);
c[i] = 1;
p[i] = i;
}
dfs(0);
memset(mark, 0, sizeof mark);
for (int i = 0; i < n; i++) {
for (int x : adj[i]) {
if (p[x] != p[i]) {
nei[p[i]].push_back(p[x]);
}
}
}
dfs2(0);
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
x--;
y--;
x = p[x], y = p[y];
if (x == y) {
cout << c[x] << endl;
continue;
}
int l = lca(x, y);
long long ans =
get(x, h[x] - h[l]).second * get(y, h[y] - h[l]).second % mod;
cout << ans * c[l] % mod << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 10e5 + 500;
const long long md = 1000000007;
const int iINF = 0x7f7f7f7f;
long long mypow(long long a, long long e) {
return e ? (e & 1 ? mypow(a, e - 1) * a % md : mypow(a * a % md, e >> 1)) : 1;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
template <class T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x = x * f;
}
int a[MAX_N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n;
int z = iINF;
long long y = 0;
cin >> n;
int maxa = -1;
for (int i = 0; i < (int)(n); ++i) {
cin >> a[i];
maxa = max(a[i], maxa);
}
qsort(a, n, sizeof(a[0]), cmp);
z = a[1] - a[0];
for (int i = 2; i < n; i++) {
z = gcd(a[i] - a[i - 1], z);
}
for (int i = 0; i < (int)(n); ++i) {
y += (maxa - a[i]) / z;
}
cout << y << " " << z << endl;
return 0;
}
| 4 |
#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(const long long &a, const long long &b) {
return a / gcd(a, b) * b;
}
const int N_MAX = 1e4;
long long arr[N_MAX];
long long pwr(long long a, long long p, const long long &mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
p >>= 1;
a = (a * a) % mod;
}
return ret;
}
vector<long long> fac;
long long f[N_MAX];
int main() {
int n, m;
long long p;
scanf("%d%d%I64d", &n, &m, &p);
for (int i = 0; i < n; i++) scanf("%I64d", arr + i);
long long unit;
scanf("%I64d", &unit);
for (int i = 1; i < m; i++) {
long long ipt;
scanf("%I64d", &ipt);
unit = gcd(unit, ipt);
}
for (long long i = 1; i * i <= (p - 1); i++) {
if ((p - 1) % i == 0) {
fac.push_back(i);
if (i * i != p - 1) fac.push_back((p - 1) / i);
}
}
sort((fac).begin(), (fac).end());
for (int i = 0; i < n; i++) {
arr[i] = pwr(arr[i], unit, p);
for (long long x : fac) {
if (pwr(arr[i], x, p) == 1) {
arr[i] = x;
break;
}
}
}
sort(arr, arr + n);
n = unique(arr, arr + n) - arr;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++)
if (arr[i] % arr[j] == 0) arr[j] = arr[i];
}
sort(arr, arr + n);
n = unique(arr, arr + n) - arr;
long long ans = 0;
for (int i = 1; i < (1 << n); i++) {
int cnt = 0;
long long tmp = 1;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
cnt++;
tmp = lcm(tmp, (p - 1) / arr[j]);
}
}
if ((cnt & 1) == 0) tmp *= (-1);
ans += (p - 1) / tmp;
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int visited[200001];
char c[1000][1000];
long long int leaf[200001], leafc;
long long int dp[200001], ind[200001], dist[200001];
vector<pair<long long int, long long int>> at_leaf(200001);
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, m;
cin >> n >> m;
long long int r;
cin >> r;
if (2 * r > min(n, m))
cout << "Second" << endl;
else
cout << "First" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 1;
int a[6];
int n;
int b[MAXN];
int ptr[MAXN];
int f[MAXN][6];
int main() {
for (int i = 0; i < 6; ++i) cin >> a[i];
cin >> n;
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 6; ++j) {
f[i][j] = b[i] - a[j];
}
sort(f[i], f[i] + 6);
}
fill(ptr, ptr + n, 0);
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
int maxv = -1;
for (int i = 0; i < n; ++i) {
pq.push(make_pair(f[i][ptr[i]], i));
maxv = max(maxv, f[i][ptr[i]]);
}
int minv = -1;
int mini = -1;
int diff = 1e9;
pair<int, int> top;
while (true) {
top = pq.top();
pq.pop();
minv = top.first;
diff = min(diff, maxv - minv);
mini = top.second;
if (ptr[mini] == 5) {
break;
}
++ptr[mini];
pq.push(make_pair(f[mini][ptr[mini]], mini));
maxv = max(maxv, f[mini][ptr[mini]]);
}
cout << diff << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010, mod = 1e9 + 7;
const long long inf = 1e18;
vector<int> v[maxn], va, vb, vc, vd, vv;
int pr[maxn];
bitset<maxn> bs;
void fnd(int a, int &A) {
while (a != 1) {
A = a;
a = pr[a];
}
}
int dfs(int u) {
int ans = (int((v[u]).size()) == 0);
for (int y : v[u]) {
ans += dfs(y);
}
return ans;
}
void go(int a, vector<int> &vv) {
int bf = -1;
while (a != 1) {
for (int y : v[a]) {
if (y != bf) vv.push_back(dfs(y));
}
bf = a;
a = pr[a];
}
}
void Do(vector<int> &vv) {
for (int x : vv) bs = bs | (bs << x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int a, b, c, d, A, B, C, D;
cin >> a >> b >> c >> d;
for (int i = 2; i <= n; i++) {
cin >> pr[i];
v[pr[i]].push_back(i);
}
fnd(a, A), fnd(b, B), fnd(c, C), fnd(d, D);
go(a, va), go(b, vb), go(c, vc), go(d, vd);
int Tot = dfs(1);
if (Tot & 1) return cout << "NO\n", 0;
for (int y : v[1]) {
if (y != A && y != B && y != C && y != D) {
vv.push_back(dfs(y));
}
}
bs = 0;
bs[0] = 1;
Do(vv), Do(va), Do(vb);
int num = (Tot / 2) - 1 - dfs(C);
if (num < 0 || bs[num] == 0) return cout << "NO\n", 0;
bs = 0;
bs[0] = 1;
Do(vv), Do(vc), Do(vd);
num = (Tot / 2) - 1 - dfs(B);
if (num < 0 || bs[num] == 0) return cout << "NO\n", 0;
return cout << "YES\n", 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int fuck(int a) {
long long int sum = 1;
for (int i = 1; i <= a; i++) sum *= 2;
return sum;
}
int main() {
int sum = 0;
long long int a, b, x, y;
cin >> x >> y;
sum = 0;
for (int i = 2; i <= 60; i++) {
a = fuck(i) - 2;
if (a >= x && a <= y) sum++;
for (int k = 1; k < i - 1; k++) {
b = a - fuck(k) + fuck(k - 1);
if (b >= x && b <= y) sum++;
a = b;
}
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5;
const int LOG = 21;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long modP(long long a, long long b) {
return (!b ? 1 : (modP(a, b / 2) * modP(a, b / 2) * (b % 2 ? a : 1)) % MOD);
}
bool flag;
long long pow2[10 * maxN], sum;
int n, k, i, u, v, t, l;
int st[maxN], fn[maxN];
int H[maxN], par[LOG][maxN];
vector<pair<int, int> > vec;
vector<int> G[maxN];
void DFSpar(int v, int p = 0, int h = 0) {
par[0][v] = p;
H[v] = h;
for (i = 1; i < LOG; i++) {
par[i][v] = par[i - 1][par[i - 1][v]];
}
for (auto u : G[v]) {
if (u != p) {
DFSpar(u, v, h + 1);
}
}
return;
}
int getpar(int v, int h) {
for (t = 0; t < LOG; t++) {
if ((1 << t) & h) {
v = par[t][v];
}
}
return v;
}
int LCA(int v, int u) {
if (H[v] < H[u]) {
swap(v, u);
}
v = getpar(v, H[v] - H[u]);
if (v == u) {
return v;
}
for (t = LOG - 1; t > -1; t--) {
if (par[t][v] != par[t][u]) {
v = par[t][v];
u = par[t][u];
}
}
return par[0][v];
}
void DFS(int v, int p = 0) {
for (auto u : G[v]) {
if (u != p) {
DFS(u, v);
st[v] += st[u];
fn[v] += fn[u];
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pow2[0] = 1;
for (i = 1; i < 10 * maxN; i++) {
pow2[i] = (pow2[i - 1] * 2) % MOD;
}
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> u >> v >> flag;
if (flag) {
vec.push_back({u, v});
}
G[u].push_back(v);
G[v].push_back(u);
}
DFSpar(1);
cin >> k;
u = 1;
for (i = 0; i < k; i++) {
cin >> v;
l = LCA(u, v);
st[u] += 1;
st[l] -= 1;
fn[v] += 1;
fn[l] -= 1;
u = v;
}
DFS(1);
for (auto e : vec) {
u = e.first;
v = e.second;
if (H[u] < H[v]) {
sum += pow2[st[v]] - 1;
} else {
sum += pow2[fn[u]] - 1;
}
sum %= MOD;
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[111111];
int v[111111], good[111111];
int main() {
int n;
int m;
cin >> n;
cin >> m;
int s;
int t;
for (int i = 0; i < m; i++) {
cin >> s;
cin >> t;
adj[s].push_back(t);
adj[t].push_back(s);
}
for (int i = 0; i < n; i++) v[i] = i + 1;
int test;
for (test = 0; test < 100; test++) {
random_shuffle(v, v + n);
int t = 0;
for (int i = 0; i < n; i++) {
good[i] = 1;
for (int j = 0; j < adj[v[i]].size(); j++)
if (adj[v[i]][j] == v[(i + 1) % n]) good[i] = 0;
if (good[i]) t++;
if (t == m) break;
}
if (t == m) break;
}
if (test == 100) {
cout << -1 << endl;
} else {
int t = 0;
for (int i = 0; i < n; i++)
if (good[i]) {
cout << v[i] << " " << v[(i + 1) % n] << endl;
t++;
if (t == m) break;
}
}
return 0;
}
| 5 |
#include <iostream>
#include <math.h>
#include <algorithm>
#include <string>
#include <string.h>
using namespace std;
int main() {
bool flag = true;
int N, M, ans = 0, a[50] = {}, b[50] = {}, C[50] = {}, k = 0;
cin >> N >> M;
for (int i = 0; i < M; i++)
{
cin >> a[i] >> b[i];
C[a[i]-1]++;
C[b[i]-1]++;
}
while (flag)
{
flag = false;
for (int i = 0; i < N; i++)
{
if (C[i]==1)
{
flag = true;
C[i] = 0;
ans++;
k = i;
break;
}
}
for (int i = 0; i < M; i++)
{
if (a[i] == k + 1)
{
C[b[i] - 1]--;
}
if (b[i] == k + 1)
{
C[a[i] - 1]--;
}
}
}
/*for (int i = 0; i < N; i++)
{
if (C[i]<=0)
{
}
}*/
cout << ans;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
long long int A;
float B;
cin>>A>>B;
int C=(int)(100*B+0.1);
cout<<A*C/100;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> v(n + 1);
for (long long i = 1; i <= n; i++) cin >> v[i];
long long f = 0;
for (long long i = 1; i <= n; i++) {
if (v[v[v[v[i]]]] == v[i]) {
f = 1;
break;
}
}
if (f == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 10;
int n, T, m;
int main() {
cin >> T;
while (T--) {
int a, b, c;
cin >> a >> b >> c;
cout << (long long)a + b + c - 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool mycomp(const pair<int, int>& A, const pair<int, int>& B) {
return A.first < B.first;
}
int main() {
int n, v;
cin >> n >> v;
vector<pair<int, int> > P;
set<int> ss;
int hash[3003];
memset(hash, 0, sizeof(hash));
pair<int, int> a;
for (int i = 0; i < n; i++) {
cin >> a.first >> a.second;
P.push_back(a);
hash[a.first] += a.second;
ss.insert(a.first);
}
long long count = 0;
int rem = 0;
set<int>::iterator it, prev;
prev = ss.begin();
int day = 0;
for (it = ss.begin(); it != ss.end(); it++) {
int flag = 0;
int day = 0;
if ((*it - *prev) < 2)
day += rem;
else if (rem <= v)
count += rem;
else
count += v;
if (hash[*it] + day <= v) {
count += hash[*it] + day;
hash[*it] = 0;
} else {
if (day <= v)
count += day;
else {
count += v;
flag = 1;
}
if (flag != 1) {
if (hash[*it] <= v - min(day, v)) {
count += hash[*it];
hash[*it] = 0;
} else if (v - min(v, day) > 0) {
count += v - min(v, day);
hash[*it] -= (v - min(v, day));
}
}
}
rem = hash[*it];
prev = it;
}
if (rem <= v)
count += rem;
else
count += v;
cout << count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2020;
const double eps = 1e-8;
int n, a, b, opt[maxn][maxn];
double dp[maxn][maxn], pa[maxn], pb[maxn], pab[maxn];
int solve(double mid) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= a; j++) {
double &d = dp[i][j];
int &o = opt[i][j];
d = dp[i - 1][j];
o = 0;
if (j && d < dp[i - 1][j - 1] + pa[i]) {
d = dp[i - 1][j - 1] + pa[i];
o = 1;
}
if (d < dp[i - 1][j] + pb[i] - mid) {
d = dp[i - 1][j] + pb[i] - mid;
o = 2;
}
if (j && d < dp[i - 1][j - 1] + pab[i] - mid) {
d = dp[i - 1][j - 1] + pab[i] - mid;
o = 3;
}
}
}
int ret = 0, la = a;
for (int i = n; i >= 1; i--) {
if (opt[i][la] > 1) ret++;
if (opt[i][la] & 1) la--;
}
return ret;
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> pa[i];
for (int i = 1; i <= n; i++) cin >> pb[i];
for (int i = 1; i <= n; i++) pab[i] = pa[i] + pb[i] - pa[i] * pb[i];
double lo = 0, hi = 1, mid;
for (int it = 0; it < 50; it++) {
mid = (lo + hi) / 2;
if (solve(mid) > b)
lo = mid;
else
hi = mid;
}
int ans = solve(hi);
cout << dp[n][a] + hi * b << endl;
return 0;
}
| 5 |
#include <iostream>
#include <tuple>
#include <queue>
#include <cmath>
#include <iomanip>
using namespace std;
constexpr double eps = 1e-10;
using data = tuple<int, double, double, double>;
int main() {
int K;
double R, L;
double P, E, T;
cin >> K >> R >> L >> P >> E >> T;
queue<data> que;
que.push(make_tuple(0, R, L, 1.0));
double res = 0;
while(!que.empty()) {
int d;
double r, l, p;
tie(d, r, l, p) = que.front(); que.pop();
double m = (r + l) / 2;
//cout << "d: " << d << " r: " << r << " l: " << l << " m: " << m << " p: " << p << endl;
if(T + E + eps < r || l + E + eps < T) {
continue;
}
if(d == K) {
if(fabs(m - T) - eps <= E) {
res += p;
}
} else {
if(T + eps < r + E && l + eps < T + E) {
res += p;
} else if(m + eps < T) {
que.push(make_tuple(d+1, m, l, p*(1-P)));
que.push(make_tuple(d+1, r, m, p*P));
} else {
que.push(make_tuple(d+1, r, m, p*(1-P)));
que.push(make_tuple(d+1, m, l, p*P));
}
}
}
cout << fixed << setprecision(10) << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 200100;
const int md = 1000000007;
const double EULER = 2.71828182845904523536;
int n, arr[1000100] = {}, x, belum = 0, ans = 0;
int main() {
scanf("%d", &n);
ans = n;
for (int i = 0; i < n; i += 1) {
scanf("%d", &x);
arr[max(0, i - x)]++;
arr[i]--;
}
for (int i = 0; i < n; i += 1) {
belum += arr[i];
if (belum) ans--;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a >= b) {
cout << b << " ";
a = a - b;
cout << a / 2;
} else {
cout << a << " ";
b = b - a;
cout << b / 2;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long double pi = acos(-1.0);
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int digarr[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int alf = 26;
const int dig = 10;
const int two = 2;
const int th = 3;
const long long int prost = 239;
const long long int btc = 30;
const long double eps = 1e-10;
const int BIG = (int)(1e9 + 239);
const long long MOD = (long long)(1e9 + 7);
const long long int MOD2 = (long long int)MOD * (long long int)MOD;
const int M = (int)(2e5 + 239);
const int N = (int)(2e3 + 239);
const int L = 20;
const int T = (1 << 20);
const int B = 500;
const int X = 1e4 + 239;
const long double EPS = 1e-10;
const long long INF = 1e18;
using namespace std;
long long int findTrailingZeros(long long int n) {
long long int count = 0;
for (long long int i = 5; n / i >= 1; i *= 5) count += n / i;
return count;
}
long long int power(long long int aa, long long int nn) {
long long int res = 1;
aa = aa % MOD;
while (nn > 0) {
if (nn & 1) res = (res * aa) % MOD;
nn = nn >> 1;
aa = (aa * aa) % MOD;
}
return res;
}
long long int nCrModp(long long int n, long long int r, long long int p) {
long long C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
long long int isPrime1(long long int n) {
if (n <= 1) return 0;
if (n == 2 || n == 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (long long int i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
struct Interval {
long start, end;
};
bool compareInterval(Interval a, Interval b) {
if (a.start != b.start)
return (a.start > b.start);
else if (a.start == b.start)
return a.end < b.end;
}
long long int countSquares(long long int a, long long int b) {
return (floor(sqrt(b)) - ceil(sqrt(a)) + 1);
}
long long int OR(long long int v[], long long int n) {
long long int ans = v[0];
for (long long int i = 1; i < n; i++) {
ans = (ans | v[i]) - v[i];
if (ans < 0) {
ans = 0;
break;
}
}
return ans;
}
long long int block(long long int x) {
vector<long long int> v;
long long int sum = 0, count = 0;
while (x > 0) {
v.push_back(x % 2);
if (x % 2 == 1) count++;
x = x / 2;
}
return count;
}
bool cmp(long long a, long long b) {
return to_string(a) + to_string(b) > to_string(b) + to_string(a);
}
string leftrotate(string s, long long int d) {
reverse(s.begin(), s.begin() + d);
reverse(s.begin() + d, s.end());
reverse(s.begin(), s.end());
return s;
}
string rightrotate(string s, long long int d) {
return leftrotate(s, s.length() - d);
}
long long int maxSubArraySum(vector<long long int>& a, long long int size) {
long long int max_so_far = INT_MIN, max_ending_here = 0;
for (long long i = 0; i < size; i++) {
max_ending_here = max(max_ending_here + a[i], a[i]);
max_so_far = max(max_so_far, max_ending_here);
}
return max_so_far;
}
long long int calc(long long int x, long long int y) {
long long int x1 = (log2(x)) + 1LL, y1 = (log2(y)) + 1LL;
long long int xx = x, yy = y;
x = (x << y1);
y = (y << x1);
y += xx;
x += yy;
return abs(y - x);
}
long long int togglebit(long long int n) {
if (n == 0) return 1;
long long int i = n;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return i ^ n;
}
long long int XNOR(long long int num1, long long int num2) {
if (num1 < num2) swap(num1, num2);
num1 = togglebit(num1);
return num1 ^ num2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int o = n % 10;
long long int u = (o - 1) * 10;
long long int z = log10(n) + 1;
if (z == 1) {
cout << u + 1 << endl;
} else if (z == 2) {
cout << u + 3 << endl;
} else if (z == 3)
cout << u + 6 << endl;
else
cout << u + 10 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag *= -1;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= flag;
return;
}
inline void read(long long &x) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag *= -1;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= flag;
return;
}
inline void read(char &c) {
while (!isalpha(c = getchar())) c = getchar();
}
long long n, W, B, X, m;
long long dp[1005][10005];
long long c[1005], cost[1005];
int main() {
read(n);
read(W);
read(B);
read(X);
for (int i = 1; i <= n; i++) {
read(c[i]);
m += c[i];
}
for (int i = 1; i <= n; i++) cin >> cost[i];
memset(dp, -1, sizeof dp);
dp[0][0] = W;
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (long long j = 0; j <= m; j++) {
long long max_mana = W + j * B;
for (int k = 0; k <= min(j, c[i]); k++) {
if (dp[i - 1][j - k] == -1) continue;
if (min(W + (j - k) * B, dp[i - 1][j - k] + X) - cost[i] * k < 0)
continue;
dp[i][j] = max(
dp[i][j], min(max_mana, min(W + (j - k) * B, dp[i - 1][j - k] + X) -
cost[i] * k));
ans = max(ans, j);
max_mana += B;
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, h, m;
string s, c, t;
bool Check() {
if (m == 60) m = 0, ++h;
if (h == 24) h = 0;
c = "";
t = "";
char f;
f = h / 10 + 48;
c = f;
f = h % 10 + 48;
c += f;
f = m / 10 + 48;
t = f;
f = m % 10 + 48;
t += f;
if (c[0] == t[1] && t[0] == c[1]) return 0;
return 1;
}
int main() {
cin >> s;
h = (s[0] - '0') * 10 + s[1] - '0';
m = (s[3] - '0') * 10 + s[4] - '0';
++m;
while (Check()) ++m;
cout << c << ":" << t;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define int long long
#define inf 1000000007
#define LINF 100000000000000007LL
#define ll long long
using namespace std;
vector<int> nex[214514];
int bg[214514],pa[214514];
int modpow(int x,int k){
// x ^ k mod inf
int res = 1;
while(k>0){
if(k%2)res = (res*x)%inf;
x = (x*x)%inf;
k >>=1;
}
return res;
}
void dfs(int pos, int par){
int res = 1;
for(int i=0;i<nex[pos].size();i++){
int nx = nex[pos][i];
if( nx != par ){
pa[nx] = pos;
dfs( nx, pos );
res += bg[nx];
}
}
bg[pos] = res;
return;
}
signed main(){
int n;
int hf = modpow( 2, inf-2 );
cin>>n;
for(int i=0;i<n-1;i++){
int x,y;
cin>>x>>y;
nex[x].pb(y);
nex[y].pb(x);
}
dfs(1,0);
int ans = 0;
for(int i=1;i<=n;i++){
vector<int> sz;
int ps = n-1;
for(int j=0;j<nex[i].size();j++){
int nx = nex[i][j];
if( nx != pa[i] ){
sz.pb(bg[nx]);
ps -= bg[nx];
}
}
if(ps!=0)sz.pb(ps);
int res = 1;
res += ( inf - modpow( hf, n-1 ) );
res %= inf;
for(int j=0;j<sz.size();j++){
int prod = modpow( hf, n-1-sz[j] ) * ( 1 + inf - modpow(hf,sz[j]) );
prod %= inf;
res += ( inf - prod );
res %= inf;
}
res *= hf;
res %= inf;
ans += res;
ans %= inf;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
enum ops { NONE, AND, OR, XOR };
struct Variable {
bool isExpr;
std::string value;
std::string lArgName;
Variable *lArg;
ops op;
std::string rArgName;
Variable *rArg;
Variable() {}
Variable(bool isExpr, const std::string &value, const std::string &lArgName,
ops op, const std::string &rArgName)
: isExpr(isExpr),
value(value),
lArgName(lArgName),
lArg(nullptr),
op(op),
rArgName(rArgName),
rArg(nullptr) {}
};
int computeSum(const std::vector<std::string> &names,
std::map<std::string, Variable> &vars, int pos);
int main() {
std::ios_base::sync_with_stdio(false);
int n, m;
std::cin >> n >> m;
std::vector<std::string> names(n);
std::map<std::string, Variable> vars;
for (int i = 0; i < n; ++i) {
std::string eq, value, lArg, opStr, rArg;
std::cin >> names[i] >> eq >> value;
bool isExpr = (value[0] != '0' and value[0] != '1');
if (isExpr) {
lArg = value;
value = std::string(m, '0');
std::cin >> opStr >> rArg;
}
ops op = ops((opStr == "AND") + 2 * (opStr == "OR") + 3 * (opStr == "XOR"));
vars[names[i]] = Variable(isExpr, value, lArg, op, rArg);
}
vars["?"] = Variable(false, std::string(m, '0'), "", NONE, "");
for (auto &var : vars)
if (var.second.isExpr) {
var.second.lArg = &vars[var.second.lArgName];
var.second.rArg = &vars[var.second.rArgName];
}
std::string minMin(m, '0');
std::string minMax(m, '0');
for (int pos = 0; pos < m; ++pos) {
vars["?"].value[pos] = '0';
int sum0 = computeSum(names, vars, pos);
vars["?"].value[pos] = '1';
int sum1 = computeSum(names, vars, pos);
minMin[pos] = (sum0 <= sum1 ? '0' : '1');
minMax[pos] = (sum0 >= sum1 ? '0' : '1');
}
std::cout << minMin << std::endl;
std::cout << minMax << std::endl;
return 0;
}
int computeSum(const std::vector<std::string> &names,
std::map<std::string, Variable> &vars, int pos) {
int sum = 0;
for (const auto &name : names) {
Variable &var = vars.at(name);
if (var.isExpr) {
int lBit = (var.lArg->value[pos] == '1');
int rBit = (var.rArg->value[pos] == '1');
int res = 0;
switch (var.op) {
case AND:
res = lBit & rBit;
break;
case OR:
res = lBit | rBit;
break;
case XOR:
res = lBit ^ rBit;
break;
}
sum += res;
var.value[pos] = (res ? '1' : '0');
}
}
return sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a;
cin >> n >> a;
int D[n];
D[0] = 1;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
D[i] = D[i - 1] + 1;
} else {
D[i] = D[i - 1];
}
}
int ans = D[n - 1];
cout << min(n, ans + 2);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int n, m, vis[101][101], cnt;
string s[101];
int dfs(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y] || s[x][y] == '.')
return 0;
vis[x][y] = 1;
for (int i = 0; i < 4; i++) dfs(x + dx[i], y + dy[i]);
return 1;
}
void code() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') continue;
cnt++;
memset(vis, 0, sizeof(vis));
int tmp = 0;
s[i][j] = '.';
for (int k = 0; k < 4; k++) tmp += dfs(i + dx[k], j + dy[k]);
if (tmp > 1) {
cout << 1 << '\n';
return;
}
s[i][j] = '#';
}
}
cout << ((cnt < 3) ? -1 : 2) << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
code();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
struct Edge {
int from, to, nxt, cap, flw;
double cost;
} e[N * N * 4];
int x[N], y[N], n, edgeCnt, head[N << 1], flw[N << 1], vis[N << 1], p[N << 1],
src, snk;
double dist[N << 2], d[N][N];
void addEdge(int u, int v, int cap, double cost) {
e[edgeCnt].from = u;
e[edgeCnt].to = v;
e[edgeCnt].cap = cap;
e[edgeCnt].flw = 0;
e[edgeCnt].cost = cost;
e[edgeCnt].nxt = head[u];
head[u] = edgeCnt++;
}
int spfa() {
memset(vis, 0, sizeof vis);
memset(flw, 0, sizeof flw);
for (int i = 0; i <= snk; i++) dist[i] = 1e8;
queue<int> q;
q.push(src);
vis[src] = 1;
flw[src] = 1e8;
dist[src] = 0;
while (!q.empty()) {
auto cur = q.front();
q.pop();
vis[cur] = 0;
for (int i = head[cur]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (e[i].cap == e[i].flw) continue;
if (dist[v] > dist[cur] + e[i].cost + 1e-7) {
dist[v] = dist[cur] + e[i].cost;
p[v] = i;
flw[v] = min(flw[cur], e[i].cap - e[i].flw);
if (!vis[v]) {
vis[v] = 1;
q.push(v);
}
}
}
}
return flw[snk] > 0;
}
void addBiEdge(int u, int v, int cap, double cost) {
addEdge(u, v, cap, cost);
addEdge(v, u, 0, -cost);
}
int main() {
scanf("%d", &n);
int mxY = INT_MIN;
for (int i = 1; i <= n; i++) {
scanf("%d%d", x + i, y + i);
mxY = max(mxY, y[i]);
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (y[i] == mxY) cnt++;
}
if (cnt > 1) return puts("-1");
src = 0, snk = n << 1 | 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
d[i][j] =
sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
memset(head, -1, sizeof head);
for (int i = 1; i <= n; i++) {
if (y[i] != mxY) {
addBiEdge(src, i, 1, 0);
}
for (int j = 1; j <= n; j++)
if (y[j] > y[i]) addBiEdge(i, n + j, 1, d[i][j]);
addBiEdge(n + i, snk, 2, 0);
}
int flw = 0;
double out = 0.0;
while (spfa()) {
flw++;
out += dist[snk];
for (int i = snk; i != src; i = e[p[i]].from) {
e[p[i]].flw++;
e[p[i] ^ 1].flw--;
}
}
if (flw < n - 1)
puts("-1");
else
printf("%0.8f\n", out);
return 0;
}
| 5 |
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <math.h>
#include <time.h>
#include <string>
#include <tuple>
#include <vector>
#include <map>
#include <unordered_map>
#include <list>
#include <set>
#include <stack>
#include <queue>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <cassert>
using namespace std;
#define LL long long
#define MP(a, b) make_pair(a, b)
#define MMP(a, b, c) make_pair(make_pair(a, b), c)
#define MAX 1000000000
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483648
#define INT_MAX 2147483647
#define LL_MIN -9223372036854775808
#define LL_MAX 9223372036854775807
#define PI 3.14159265359
vector<pair<int,int> > house;
vector<pair<int,int>> way[23];
int ok[23];
int solve(int i, int j){
if(i == (1<<house.size())-1) return ok[j];
int ans = 0;
if((i&(1<<j)) == 0) return 0;
bool flg = true;
for(int k=way[j].size()-1; k>=0; k--){
if(way[j][k] == MP(-1,-1)){
flg = true;
continue;
}
if(flg == false) continue;
if((i&way[j][k].second) == way[j][k].second && (i&(1<<way[j][k].first)) == 0){
ans += solve(i+(1<<way[j][k].first), way[j][k].first);
flg = false;
}
}
return ans;
}
int main() {
iostream::sync_with_stdio(false);
START:
int m,n;
cin >> m >> n;
if(n == 0 && m == 0) return 0;
int a[10][10];
house.clear();
pair<int,int> kyokai;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if(a[i][j] == 0) a[i][j] = -1; //空地
else if(a[i][j] == 2){
a[i][j] = -2; //教会
kyokai = MP(i,j);
}
else{
a[i][j] = house.size();
house.push_back(MP(i,j));
}
}
}
//経路計算
for(int i=0; i<house.size(); i++){
way[i].clear();
int x = house[i].first;
int y = house[i].second;
int tmp = 0;
for(int j=x+1; j<n; j++){
if(a[j][y] >= 0){
way[i].push_back(MP(a[j][y],tmp));
tmp += 1<<a[j][y];
}
}
way[i].push_back(MP(-1,-1));
tmp = 0;
for(int j=x-1; j>=0; j--){
if(a[j][y] >= 0){
way[i].push_back(MP(a[j][y],tmp));
tmp += 1<<a[j][y];
}
}
way[i].push_back(MP(-1,-1));
tmp = 0;
for(int j=y+1; j<m; j++){
if(a[x][j] >= 0){
way[i].push_back(MP(a[x][j],tmp));
tmp += 1<<a[x][j];
}
}
way[i].push_back(MP(-1,-1));
tmp = 0;
for(int j=y-1; j>=0; j--){
if(a[x][j] >= 0){
way[i].push_back(MP(a[x][j],tmp));
tmp += 1<<a[x][j];
}
}
}
//教会隣接家dp初期化
for(int i=0; i<house.size(); i++){
ok[i] = 0;
}
for(int i=kyokai.first+1; i<n; i++){
if(a[i][kyokai.second] >= 0){
ok[a[i][kyokai.second]] = 1;
}
}
for(int i=kyokai.first-1; i>=0; i--){
if(a[i][kyokai.second] >= 0){
ok[a[i][kyokai.second]] = 1;
}
}
for(int i=kyokai.second+1; i<m; i++){
if(a[kyokai.first][i] >= 0){
ok[a[kyokai.first][i]] = 1;
}
}
for(int i=kyokai.second-1; i>=0; i--){
if(a[kyokai.first][i] >= 0){
ok[a[kyokai.first][i]] = 1;
}
}
//最終的な答え
int ans = 0;
for(int i=kyokai.first+1; i<n; i++){
if(a[i][kyokai.second] >= 0){
ans += solve(1<<a[i][kyokai.second],a[i][kyokai.second]);
break;
}
}
for(int i=kyokai.first-1; i>=0; i--){
if(a[i][kyokai.second] >= 0){
ans += solve(1<<a[i][kyokai.second],a[i][kyokai.second]);
break;
}
}
for(int i=kyokai.second+1; i<m; i++){
if(a[kyokai.first][i] >= 0){
ans += solve(1<<a[kyokai.first][i],a[kyokai.first][i]);
break;
}
}
for(int i=kyokai.second-1; i>=0; i--){
if(a[kyokai.first][i] >= 0){
ans += solve(1<<a[kyokai.first][i],a[kyokai.first][i]);
break;
}
}
cout << ans << endl;
goto START;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int A[200005] , T[200005];
int main() {
int N;
cin >> N;
ll ans = 0;
for(int i = 0; i < N; i++){
cin >> A[i];
ans+=T[A[i]];
T[A[i]]++;
}
for(int i = 0; i < N; i++){
cout << ans - T[A[i]] + 1 << endl;
}
} | 0 |
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main(){
string s;
cin >> s;
int fn='A';
int cou=0;
//cout << fn << endl;
for(int i=0;i<s.size();i++){
if(s[i] <= fn )cou++;
fn=s[i];
}
cout << cou << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
vector<int> adj[N], mem[N];
int cap[N][N], edge[N][N], visit[N], p[N], n, source, sink, a[N], cnt, max_flow;
int is_prime(int a) {
for (int i = 2; i * i <= a; i++)
if (a % i == 0) return 0;
return 1;
}
void add(int u, int v, int _cap) {
adj[u].push_back(v);
adj[v].push_back(u);
cap[u][v] = _cap;
edge[u][v] = 1;
}
int bfs() {
memset(visit, 0, sizeof visit);
queue<int> q;
q.push(source);
visit[source] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
if (u == sink) return 1;
for (int v : adj[u])
if (cap[u][v] && !visit[v]) {
visit[v] = 1;
p[v] = u;
q.push(v);
}
}
return 0;
}
void dfs(int u) {
visit[u] = 1;
mem[cnt].push_back(u);
for (int v : adj[u])
if (!visit[v]) dfs(v);
}
int main() {
cin >> n;
source = 0;
sink = n + 1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] % 2)
add(source, i, 2);
else
add(i, sink, 2);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i] % 2 && a[j] % 2 == 0 && is_prime(a[i] + a[j])) add(i, j, 1);
while (bfs()) {
int flow_path = 1e9;
for (int v = sink; v != source; v = p[v])
flow_path = min(flow_path, cap[p[v]][v]);
max_flow += flow_path;
for (int v = sink; v != source; v = p[v]) {
cap[p[v]][v] -= flow_path;
cap[v][p[v]] += flow_path;
}
}
if (max_flow != n) {
cout << "Impossible";
return 0;
}
for (int i = 1; i <= n; i++) adj[i].clear();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (edge[i][j] && !cap[i][j]) {
adj[i].push_back(j);
adj[j].push_back(i);
}
memset(visit, 0, sizeof visit);
for (int i = 1; i <= n; i++) {
if (!visit[i]) {
cnt++;
dfs(i);
}
}
cout << cnt << '\n';
for (int i = 1; i <= cnt; i++) {
cout << mem[i].size() << ' ';
for (int j : mem[i]) cout << j << ' ';
cout << '\n';
}
}
| 3 |
#include<iostream>
using namespace std;
int a[301][301];
bool ok[301][301];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
cin>>a[i][j];
}
}
for(int k=1;k<=n;k++)
{
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i!=j&&i!=k&&j!=k)
{
if(a[i][j]>a[i][k]+a[k][j])
{
cout<<-1<<endl;
return 0;
}
else if(a[i][j]==a[i][k]+a[k][j])
{
ok[i][j]=1;
}
}
}
}
}
long long ans=0;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(ok[i][j]==0) ans+=a[i][j];
}
}
cout<<ans/2<<endl;
return 0;
} | 0 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = double;
const ld eps = 1e-9;
//
//using Graph = vector<vector<int>>;
//
//int dfs(const Graph&g, const int now, vector<int>&ch_cnts) {
// ch_cnts[now]++;
// for (auto&& e : g[now]) {
// ch_cnts[now] += dfs(g, e, ch_cnts);
// }
// return ch_cnts[now];
//}
//
//struct HL_Edge {
// int from;
// int to;
// bool heavy;
//};
//
//void dfs2(const Graph&g, vector<vector<HL_Edge>>&hl_tree, const int now, const vector<int>&ch_cnts) {
//
// int max_ch_id = 1;
// {
// int max_ch_num = -1;
// for (auto&&e : g[now]) {
// if (max_ch_num < ch_cnts[e]) {
// max_ch_num = ch_cnts[e];
// max_ch_id = e;
// }
// }
// }
// for (auto e : g[now]) {
// bool heavy = (e == max_ch_id);
//
// hl_tree[now].push_back(HL_Edge{ now,e,heavy });
// }
// return;
//}
//
//void HL(const vector<vector<int>>&ro_tree) {
// vector<int>ch_cnts(ro_tree.size());
//
// dfs(ro_tree, 0, ch_cnts);
//
// vector<vector<HL_Edge>>hl_tree(ro_tree.size());
//
// dfs2(ro_tree, hl_tree, 0, ch_cnts);
//}
//
//namespace FastFourierTransform
//{
// using C = complex< double >;
//
// void DiscreteFourierTransform(vector< C > &F, bool rev)
// {
// const int N = (int)F.size();
// const double PI = (rev ? -1 : 1) * acos(-1);
// for (int i = 0, j = 1; j + 1 < N; j++) {
// for (int k = N >> 1; k > (i ^= k); k >>= 1);
// if (i > j) swap(F[i], F[j]);
// }
// C w, s, t;
// for (int i = 1; i < N; i <<= 1) {
// for (int k = 0; k < i; k++) {
// w = polar(1.0, PI / i * k);
// for (int j = 0; j < N; j += i * 2) {
// s = F[j + k];
// t = C(F[j + k + i].real() * w.real() - F[j + k + i].imag() * w.imag(),
// F[j + k + i].real() * w.imag() + F[j + k + i].imag() * w.real());
// F[j + k] = s + t, F[j + k + i] = s - t;
// }
// }
// }
// if (rev) for (int i = 0; i < N; i++) F[i] /= N;
// }
//
// vector< int> Multiply(const vector<int > &A, const vector<int > &B)
// {
// int sz = 1;
// while (sz <= A.size() + B.size()) sz <<= 1;
// vector< C > F(sz), G(sz);
// for (int i = 0; i < A.size(); i++) F[i] = A[i];
// for (int i = 0; i < B.size(); i++) G[i] = B[i];
// DiscreteFourierTransform(F, false);
// DiscreteFourierTransform(G, false);
// for (int i = 0; i < sz; i++) F[i] *= G[i];
// DiscreteFourierTransform(F, true);
// vector< int > X(A.size() + B.size() - 1);
// for (int i = 0; i < A.size() + B.size() - 1; i++) X[i] = F[i].real() + 0.5;
// return (X);
// }
//};
struct aa {
string name;
int l;
int r;
int u;
int d;
vector<shared_ptr<aa>>chs;
};
int get_num(string st, int&a) {
int num=0;
while (a != st.size() && isdigit(st[a])) {
num*=10;
num+=st[a]-'0';
a++;
}
return num;
}
string get_name(string st, int &a) {
string name="";
while (a != st.size() && 'a' <= st[a] && st[a] <= 'z') {
name+=st[a];
a++;
}
return name;
}
string get_on_name(string st,bool flag, int &a) {
assert(st[a]=='<');
a++;
if (flag) {
assert(st[a]=='/');
a++;
}
string name=get_name(st,a);
assert(st[a]=='>');
a++;
return name;
}
pair<pair<int, int>, pair<int, int>>get_on_num(string st, int &a) {
int l=get_num(st,a);
assert(st[a]==',');
a++;
int u=get_num(st,a);
assert(st[a]==',');
a++;
int r=get_num(st,a);
assert(st[a]==',');
a++;
int d=get_num(st,a);
return make_pair(make_pair(l,r),make_pair(u,d));
}
shared_ptr<aa>solve(string st, int &a) {
aa now;
string aname=get_on_name(st,false,a);
now.name=aname;
auto p=get_on_num(st,a);
now.l=p.first.first;
now.r=p.first.second;
now.u=p.second.first;
now.d=p.second.second;
while (st[a + 1] != '/') {
auto naa=solve(st,a);
now.chs.push_back(naa);
}
get_on_name(st,true,a);
return make_shared<aa>(now);
}
vector<string> split(const string &str, char delim) {
vector<string> res;
size_t current = 0, found;
while ((found = str.find_first_of(delim, current)) != string::npos) {
res.push_back(string(str, current, found - current));
current = found + 1;
}
res.push_back(string(str, current, str.size() - current));
return res;
}
int main() {
while (true) {
string st;
getline(cin,st);
if(st=="END OF INPUT")break;
auto ps=split(st,' ');
string anss;
for (auto p : ps) {
anss.push_back('0'+p.size());
}
cout<<anss<<endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<queue>
#include<stack>
#include<assert.h>
using namespace std;
#define MOD 1000000007
#define INF (1<<29)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long Int;
typedef pair<Int, Int> P;
vector<P> points;
Int n, x;
Int b[216000];
Int l[216000];
Int u[216000];
Int val = 0;
bool ok(Int score){
Int all = score / x;
Int part = score % x;
for(int i = 0;i < n;i++){
Int V = 0;
if(i < all) V += points[all].first - (points[i].first - (i?points[i-1].first:0)) ;
else V += all?points[all-1].first:0;
int id = points[i].second;
V += l[id] * min(b[id], part);
V += u[id] * max(0LL, part - b[id]);
if(V >=val)return true;
}
return false;
}
int main(){
cin >> n >> x;
for(int i = 0;i < n;i++){
cin >> b[i] >> l[i] >> u[i];
val += b[i] * l[i];
points.push_back(P(b[i] * l[i] + u[i] * (x-b[i]),i));
}
sort(points.rbegin(), points.rend());
for(int i = 1;i < n;i++){
points[i].first += points[i-1].first;
}
Int bottom = 0, top = n*x;
while(top - bottom > 1){
Int mid = (top + bottom) / 2;
if(ok(mid))top = mid;
else bottom = mid;
}
if(ok(0))top = 0;
cout << top << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b;
long long val;
cin >> t;
while (t--) {
cin >> a >> b;
if (!(a % b)) {
puts("0");
} else if (b > a) {
cout << b - a << endl;
} else {
val = a / b + 1;
cout << b * val - a << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0;
cin >> n;
while (n--) {
int a, b, c, d = 0, e = 0, f = 0;
cin >> a >> b >> c;
if (a + b == 2) {
d += 1;
}
if (b + c == 2) {
e += 1;
}
if (a + c == 2) {
f += 1;
}
if (d + e + f > 0) {
sum += 1;
}
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long freq[n], arr[n];
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
freq[arr[i]] = i;
}
long long ans = 0;
for (long long i = 1; i < n; i++) {
ans += abs(freq[i] - freq[i + 1]);
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, x, j, v[10], nr, ok;
int main() {
cin >> n;
cin >> k;
for (i = 1; i <= n; i++) {
cin >> x;
for (j = 0; j <= 9; j++) v[j] = 0;
do {
v[x % 10] = 1;
x /= 10;
} while (x);
ok = 1;
for (j = 0; j <= k; j++) {
if (v[j] == 0) ok = 0;
}
if (ok == 1) nr++;
}
cout << nr;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, K, a[N];
struct data {
long long ans;
vector<pair<int, int> > l, r;
data() {
l.clear();
r.clear();
ans = 0;
}
data(int x) {
l.clear();
r.clear();
l.emplace_back(x, 1);
r.emplace_back(x, 1);
ans = (x >= K);
}
void merge(const vector<pair<int, int> >& a, const vector<pair<int, int> >& b,
vector<pair<int, int> >& c) const {
c = a;
if (c.empty()) c.emplace_back(b[0].first, 0);
for (auto i : b)
if ((c.back().first | i.first) == c.back().first)
c.back().second += i.second;
else
c.emplace_back(c.back().first | i.first, i.second);
}
data operator+(const data& a) const {
data b;
b.ans = ans + a.ans;
merge(l, a.l, b.l);
merge(a.r, r, b.r);
for (int i = 0, j = a.l.size(), tmp = 0; i < (int)r.size(); ++i) {
for (; j && (r[i].first | a.l[j - 1].first) >= K; tmp += a.l[j].second)
--j;
b.ans += (long long)tmp * r[i].second;
}
return b;
}
} S[N * 4], q3;
void bt(int o, int l, int r) {
if (l == r) {
S[o] = data(a[l]);
return;
}
int mid = (l + r) / 2;
bt(o * 2, l, mid);
bt(o * 2 + 1, mid + 1, r);
S[o] = S[o * 2] + S[o * 2 + 1];
}
int q1, q2;
void mdf(int o, int l, int r) {
if (l == r) {
S[o] = data(q2);
return;
}
int mid = (l + r) / 2;
if (q1 <= mid)
mdf(o * 2, l, mid);
else
mdf(o * 2 + 1, mid + 1, r);
S[o] = S[o * 2] + S[o * 2 + 1];
}
void qry(int o, int l, int r) {
if (q1 <= l && r <= q2) {
q3 = q3 + S[o];
return;
}
int mid = (l + r) / 2;
if (q1 <= mid) qry(o * 2, l, mid);
if (q2 > mid) qry(o * 2 + 1, mid + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> K;
for (int i = 1; i <= n; ++i) cin >> a[i];
bt(1, 1, n);
for (; m-- > 0;) {
int op;
cin >> op >> q1 >> q2;
if (op == 1)
mdf(1, 1, n);
else {
q3 = data();
qry(1, 1, n);
cout << q3.ans << '\n';
}
}
return 0;
}
| 6 |
// Created by liszt on 2019/07/21.
#include<bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
int a=0,b=0;
for(int i=0;i<s.size();i++){
if((i%2)^(s[i]=='1'))a++;
else b++;
}
cout<<(a<b ? a : b)<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[(int)(2 * 1e5 + 10)];
long long pa[(int)(2 * 1e5 + 10)];
long long sa[(int)(2 * 1e5 + 10)];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
pa[i] = 1ll * a[i] + pa[i - 1];
}
for (int i = n; i >= 1; --i) {
sa[i] = 1ll * a[i] + sa[i + 1];
}
int x = n;
long long mx = 0;
int i = 1;
while (i <= n) {
if (i < x) {
if (pa[i] > sa[x])
--x;
else if (pa[i] < sa[x])
++i;
else
mx = max(mx, pa[i]), ++i, --x;
} else
break;
}
cout << mx << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[100010], n, x, ans = 0, mini = 20000000000;
scanf("%lld%lld", &n, &x);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
mini = min(mini, a[i]);
}
while (a[x] != mini) {
a[x]--;
ans++;
x--;
if (x == 0) x = n;
}
for (int i = 1; i <= n; i++) {
if (i != x)
printf("%lld ", a[i] - mini);
else {
ans += n * mini;
printf("%lld ", ans);
}
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7fffffffffffffff;
const double eps = 1e-8;
unsigned int seed = 19260817;
const unsigned int _RAND_MAX_ = 4294967295u;
__inline__ __attribute__((always_inline)) unsigned int Rand() {
return seed = seed * 998244353u + 1000000007u;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) bool _cmp(const _Tp &a,
const _Tp &b) {
return abs(a - b) <= eps;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 2005;
const int mod = 1000000007;
char s[N][N];
int dp[N][N];
int cnt1[N][N], cnt2[N][N];
__inline__ __attribute__((always_inline)) void _add(int &A, const int &B) {
(A += B) >= mod && (A -= mod);
}
__inline__ __attribute__((always_inline)) void _sub(int &A, const int &B) {
(A -= B) < 0 && (A += mod);
}
struct BIT {
int c[N];
__inline__ __attribute__((always_inline)) void add(int x, const int &C) {
for (; x <= 2000; x += ((x) & (-x))) {
_add(c[x], C);
}
}
__inline__ __attribute__((always_inline)) void sub(int x, const int &C) {
for (; x <= 2000; x += ((x) & (-x))) {
_sub(c[x], C);
}
}
__inline__ __attribute__((always_inline)) int sum(int x) {
int ans = 0;
for (; x; x -= ((x) & (-x))) {
_add(ans, c[x]);
}
return ans;
}
} tr1[N], tr2[N];
__inline__ __attribute__((always_inline)) void Upd1(int x, int l, int r,
const int &C) {
tr1[x].add(l, C);
tr1[x].sub(r + 1, C);
}
__inline__ __attribute__((always_inline)) void Upd2(int x, int l, int r,
const int &C) {
tr2[x].add(l, C);
tr2[x].sub(r + 1, C);
}
int main() {
int n, m;
read(n, m);
if (n == 1 && m == 1) {
printf("1\n");
return 0;
}
for (int i = 1; i <= n; ++i) {
read_str(s[i] + 1);
int cnt = 0;
for (int j = 1; j <= m; ++j) {
cnt += s[i][j] == 'R';
cnt1[i][j] = cnt;
}
}
for (int i = 1; i <= m; ++i) {
int cnt = 0;
for (int j = 2; j <= n; ++j) {
cnt += s[j][i] == 'R';
cnt2[j][i] = cnt;
}
}
Upd1(1, 1, 1, 1);
Upd2(1, 1, 1, 1);
int a = 0, b = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a = tr1[i].sum(j);
b = tr2[j].sum(i);
int sum = cnt2[n][j] - cnt2[i][j];
Upd2(j, i + 1, n - sum, a);
sum = cnt1[i][m] - cnt1[i][j];
Upd1(i, j + 1, m - sum, b);
}
}
_add(a, b);
printf("%d\n", a);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const char radix[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
'9', '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 string R_M[] = {"", "M", "MM", "MMM"};
const string R_C[] = {"", "C", "CC", "CCC", "CD",
"D", "DC", "DCC", "DCCC", "CM"};
const string R_X[] = {"", "X", "XX", "XXX", "XL",
"L", "LX", "LXX", "LXXX", "XC"};
const string R_I[] = {"", "I", "II", "III", "IV",
"V", "VI", "VII", "VIII", "IX"};
int main() {
string b, c;
int a;
cin >> a >> b >> c;
long long int digit = 0;
for (int i = 0, size = c.size(); i < size; ++i) {
long long int tmp;
if (isdigit(c[i]))
tmp = c[i] - '0';
else
tmp = c[i] - 'A' + 10;
long long int b = 1;
for (int j = 0; j < size - 1 - i; ++j) b *= a;
b *= tmp;
digit += b;
}
string ans = "";
if (b != "R") {
int r = atoi(b.c_str());
while (digit != 0) {
ans = radix[digit % r] + ans;
digit /= r;
}
} else {
int M = digit / 1000;
digit %= 1000;
int C = digit / 100;
digit %= 100;
int X = digit / 10;
int I = digit % 10;
ans = R_M[M] + R_C[C] + R_X[X] + R_I[I];
}
if (ans == "") ans = "0";
cout << ans << endl;
return 0;
}
| 3 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<ll> a[3];
for (int i = 0; i < N; i++) {
for (int j = 0; j < 3; j++) {
ll n; cin >> n;
a[j].push_back(n);
}
}
ll res=0;
for (int bit = 0; bit < (1 << 3); bit++) {
vector<ll> b;
for (int i = 0; i < N; i++) {
ll tmp=0;
for (int j = 0; j < 3; j++) {
if(bit & (1<<j)) tmp += a[j][i];
else tmp -= a[j][i];
}
b.push_back(tmp);
}
sort(b.begin(), b.end(), greater<ll>());
ll sum=0;
for (int i = 0; i < M; i++) {
sum += b[i];
}
res = max(res, sum);
}
cout << res << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N;
vector<ll> par;
void initialize(){
for(ll i = 1; i < 10000000; i++){
par[i] = i;} //始めは任意のノードの親が自分自身
}
ll root(ll x){
if(par[x] == x){ return x;}
else{ return par[x] = root(par[x]);}}
void unite(ll x, ll y){
if( root(x) == root(y)){ return;}
else{
par[root(x)] = root(y);}}
bool issame(ll x, ll y){
return root(x) == root(y);}
int main(){
ll M; cin >> N >> M; par.resize(10000000); initialize();
for(ll i = 1; i <= N; i++){ ll p; cin >> p; unite(p,i+100000);}
for(ll i = 0; i < M; i++){
ll x,y; cin >> x >> y; unite(x,y);}
ll cnt = 0;
for(ll i = 1; i <= N; i++){
if(issame(i,i+100000)){ cnt++;}}
cout << cnt << endl; return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n;
long long k, a[107], f[107][107] = {}, res[107][107] = {}, result = 0;
void mul(long long a[107][107], long long b[107][107]) {
long long res[107][107] = {};
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
for (long long k = 0; k < n; k++)
res[i][j] = (res[i][j] + a[i][k] * b[k][j] % mod) % mod;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) a[i][j] = res[i][j];
}
signed main() {
cin >> n >> k;
k -= 1;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++)
if (__builtin_popcountll(a[i] ^ a[j]) % 3 == 0) f[i][j] = 1;
for (long long i = 0; i < n; i++) res[i][i] = 1;
while (k) {
if (k % 2) mul(res, f);
mul(f, f);
k /= 2;
}
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) result = (result + res[i][j]) % mod;
cout << result;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int pw[100005], mn[35];
vector<int> bit[35];
int idx[35];
int main() {
pw[0] = 1;
for (int i = 1; i <= 100000; i++) pw[i] = (pw[i - 1] * 2) % mod;
for (int i = 0; i <= 21; i++) mn[i] = 1e9, idx[i] = 1;
mn[0] = 0;
int n, q;
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
int b = a, cnt = 0;
while (b) cnt++, b /= 2;
bit[cnt].push_back(a);
mn[cnt] = min(mn[cnt], i);
for (int j = 21; j > 0; j--) {
while (idx[j] < bit[j].size()) {
int x = bit[j][0] ^ bit[j][idx[j]];
int b = x;
int cnt = 0;
while (b) cnt++, b /= 2;
bit[cnt].push_back(x);
mn[cnt] = min(mn[cnt], i);
idx[j]++;
}
}
}
for (int i = 0; i < q; i++) {
int l, x;
scanf("%d%d", &l, &x);
bool ok = 1;
int cnt = 0;
for (int j = 20; j >= 0; j--) {
if (mn[j + 1] <= l) cnt++;
if ((x >> j) & 1) {
if (mn[j + 1] <= l) {
x ^= bit[j + 1][0];
continue;
}
ok = 0;
}
}
int ans = pw[l - cnt];
if (!ok) ans = 0;
printf("%d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5100;
int dp[N][N], x[N], n, m;
void read() {
string junk;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x[i] >> junk;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
dp[i][j] = dp[i - 1][j];
if (j == x[i])
for (int k = x[i]; k >= 1; k--)
dp[i][j] = max(dp[i - 1][k] + 1, dp[i][j]);
}
for (int i = 1; i <= m; i++) dp[n][m + 1] = max(dp[n][m + 1], dp[n][i]);
cout << n - dp[n][m + 1] << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b; cin>>a>>b;
cout<<(a-1)*(b-1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
long long dp[N][2][2];
int arr[N];
int n;
long long solve(int idx, bool take, int sign) {
if (idx == n) return 0;
long long& cur = dp[idx][take][sign + 1];
if (cur != -1) return cur;
if (take) {
return cur = max(0ll, ((long long)(arr[idx] * sign)) +
solve(idx + 1, take, sign * -1));
} else {
return cur = max(solve(idx + 1, take, sign),
arr[idx] + solve(idx + 1, 1, -1));
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof(dp));
int num;
cin >> n >> num;
--n;
for (int i = 0; i < n; ++i) {
int cur;
cin >> cur;
arr[i] = abs(cur - num);
num = cur;
}
cout << solve(0, 0, 0);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
template <class T>
bool cmn(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool cmx(T &a, T b) {
return a < b ? (a = b, true) : false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<vector<int>> gr(m + 1);
set<int> caps;
vector<vector<int>> vec(n);
for (int i = 0; i < n; ++i) {
int val;
cin >> val;
vec[i].resize(val);
for (int j = 0; j < val; ++j) {
cin >> vec[i][j];
}
}
for (int i = 1; i < n; ++i) {
int si = min(static_cast<int>((vec[i - 1]).size()),
static_cast<int>((vec[i]).size()));
for (int j = 0; j < si; ++j) {
if (vec[i - 1][j] > vec[i][j]) {
caps.insert(vec[i - 1][j]);
break;
} else if (vec[i - 1][j] < vec[i][j]) {
gr[vec[i][j]].push_back(vec[i - 1][j]);
break;
}
}
}
set<int> act_caps;
function<void(int)> dfs = [&](int s) {
act_caps.insert(s);
for (auto x : gr[s]) {
if (!act_caps.count(x)) dfs(x);
}
};
for (int i = 1; i <= m; ++i) {
if (caps.count(i)) {
dfs(i);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < static_cast<int>((vec[i]).size()); ++j) {
if (!act_caps.count(vec[i][j])) {
vec[i][j] += m;
}
}
}
for (int i = 1; i < n; ++i) {
int si = min(static_cast<int>((vec[i - 1]).size()),
static_cast<int>((vec[i]).size()));
bool flag = false;
for (int j = 0; j < si; ++j) {
if (vec[i - 1][j] < vec[i][j]) {
flag = true;
break;
} else if (vec[i - 1][j] > vec[i][j]) {
cout << "No\n";
return 0;
}
}
if (!flag && static_cast<int>((vec[i - 1]).size()) >
static_cast<int>((vec[i]).size())) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n" << static_cast<int>((act_caps).size()) << '\n';
for (int x : act_caps) cout << x << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a;
cin >> n >> a;
double angleone = 180.0 / n;
double min = 180;
int minn = 0;
for (int i = 1; i <= n - 2; i++) {
if (abs(i * angleone - a) < min) {
min = abs(i * angleone - a);
minn = i;
}
}
cout << "2 1 " << minn + 2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int c, int n) {
int mi = min(c, n);
int xm = max(c, n);
if (mi == 0) return xm;
while (xm % mi != 0) {
int m = mi;
mi = xm % mi;
xm = m;
}
return mi;
}
int main() {
string s;
getline(cin, s);
bool b[125];
int ans = 0;
memset(b, false, sizeof(b));
for (int i = 1; i < s.size() - 1; i++) {
int w = s[i];
if (w >= 97 && w <= 122 && b[w] == false) {
ans++;
b[w] = true;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
const int sqrtN = 512;
const ll inf = (1LL<<31)-1;
int n, q;
cin >> n >> q;
int bucket_sz = (n+sqrtN-1)/sqrtN;
vector<ll> a(n, inf);
vector<ll> bucketMin(bucket_sz, inf);
vector<ll> bucketUp(bucket_sz, 0);
vector<bool> bucketFlag(bucket_sz, false);
auto push = [&](int k) {
bucketFlag[k] = false;
int l = k*sqrtN, r = (k+1)*sqrtN;
for(int i = l; i < r; ++i) {
a[i] = bucketUp[k];
}
};
auto update = [&](int s, int t, int x) {
for(int i = 0; i < bucket_sz; ++i) {
int l = i*sqrtN, r = (i+1)*sqrtN;
if(r <= s || t <= l) continue;
if(s <= l && r <= t) {
bucketMin[i] = x;
bucketUp[i] = x;
bucketFlag[i] = true;
} else {
if(bucketFlag[i]) push(i);
for(int j = max(s, l); j < min(t, r); ++j) {
a[j] = x;
}
ll mn = inf;
for(int j = l; j < r; ++j) mn = min(mn, a[j]);
bucketMin[i] = mn;
}
}
};
auto query = [&](int s, int t) -> ll {
ll mn = inf;
for(int i = 0; i < bucket_sz; ++i) {
int l = i*sqrtN, r = (i+1)*sqrtN;
if(r <= s || t <= l) continue;
if(s <= l && r <= t) {
mn = min(mn, bucketMin[i]);
} else {
if(bucketFlag[i]) push(i);
for(int j = max(s, l); j < min(t, r); ++j) {
mn = min(mn, a[j]);
}
}
}
return mn;
};
while(q--) {
int t;
cin >> t;
if(t == 0) {
ll s, t, x;
cin >> s >> t >> x;
update(s, t+1, x);
} else {
ll s, t;
cin >> s >> t;
cout << query(s, t+1) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
vector<int> a(n), b(n);
for (int i = 1; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
cin >> b[i];
}
int dp[n][2];
memset(dp, 0, sizeof(dp));
dp[0][1] = c;
for (int i = 1; i < n; i++) {
dp[i][0] = min(dp[i - 1][0] + a[i], dp[i - 1][1] + a[i]);
dp[i][1] = min(dp[i - 1][1] + b[i], dp[i - 1][0] + c + b[i]);
}
for (int i = 0; i < n; i++) {
cout << min(dp[i][0], dp[i][1]) << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double a, b, c;
double A, B, C;
double S;
double R;
const double pi = acos(-1);
void getAngle() {
A = acos((b * b + c * c - a * a) / (2 * b * c));
B = acos((a * a + c * c - b * b) / (2 * a * c));
C = acos((b * b + a * a - c * c) / (2 * b * a));
}
double getArea() { return 0.5 * a * c * sin(B); }
double getRadius() { return (a * b * c) / (4 * S); }
double gcd(double a, double b) {
double eqs = 0.0001;
return a < eqs ? b : gcd(fmod(b, a), a);
}
int main() {
double x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
a = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
b = sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3));
c = sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2));
getAngle();
S = getArea();
R = getRadius();
double n = pi / gcd(gcd(A, C), B);
double result;
result = n * 0.5 * R * sin(pi / n) * 2 * R * cos(pi / n);
cout << fixed << setprecision(8) << result << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int power[32] = {0};
bool compar(vector<int> &v1, vector<int> &v2) { return v1 < v2; }
void solve() {
int n;
cin >> n;
vector<pair<vector<int>, int>> v1, v2;
vector<int> p(n + 1);
for (int j = 1; j <= n; j++) {
cin >> p[j];
}
for (int i = 0; i < power[15]; i++) {
vector<int> r1;
for (int j = 1; j <= n; j++) {
int c = (p[j] ^ i);
int cnt = 0;
for (int q = 0; q < 15; q++)
if (power[q] & c) cnt++;
r1.push_back(cnt);
}
v1.push_back(make_pair(r1, i));
vector<int> r2;
for (int j = 1; j <= n; j++) {
int cnt = 0;
int c = (p[j] ^ (i * power[15]));
for (int q = 15; q <= 30; q++)
if (power[q] & c) cnt++;
r2.push_back(cnt);
}
v2.push_back(make_pair(r2, i));
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
for (auto u : v1) {
int x1 = u.second;
vector<int> v = u.first;
for (int j = 0; j <= 30; j++) {
vector<int> req;
for (auto i : v) {
if (i > j) {
break;
}
req.push_back(j - i);
}
if ((int)req.size() < n) continue;
int l = 0, r = (int)v2.size() - 1;
while (r - l + 1 > 2) {
int x = (l + r) / 2;
if (compar(v2[x].first, req)) {
l = x;
} else {
r = x;
}
}
if (r - l + 1 == 2) {
if (v2[l].first == req) {
cout << v2[l].second * power[15] + x1 << "\n";
return;
} else if (v2[r].first == req) {
cout << v2[r].second * power[15] + x1 << "\n";
return;
}
}
if (r - l + 1 == 1) {
if (v2[l].first == req) {
cout << v2[l].second * power[15] + x1 << "\n";
return;
}
}
}
}
cout << -1 << "\n";
return;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
power[0] = 1;
for (int j = 1; j <= 30; j++) power[j] = power[j - 1] * 2;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d, i, j, h, k, ans, cnt, f, mans = -1;
int a[105][105];
int main() {
scanf("%d%d%d", &n, &m, &d);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
}
}
for (h = 1; h <= n; h++) {
for (k = 1; k <= m; k++) {
f = ans = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (a[i][j] != a[h][k]) {
cnt = abs(a[i][j] - a[h][k]);
if (cnt % d != 0) {
f = 1;
break;
} else {
ans += cnt / d;
}
}
}
if (f == 1) {
break;
}
}
if (f == 0 && (mans == -1 || ans < mans)) mans = ans;
}
}
printf("%d\n", mans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int binarySearch(int arr[], int l, int r, int x) {
while (l <= r) {
int m = l + (r - l) / 2;
if (arr[m] == x) return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
int main() {
string n;
getline(cin, n);
n.erase(remove(n.begin(), n.end(), ' '), n.end());
if (n.at(n.size() - 2) == 'a' || n.at(n.size() - 2) == 'A' ||
n.at(n.size() - 2) == 'e' || n.at(n.size() - 2) == 'E' ||
n.at(n.size() - 2) == 'o' || n.at(n.size() - 2) == 'O' ||
n.at(n.size() - 2) == 'u' || n.at(n.size() - 2) == 'U' ||
n.at(n.size() - 2) == 'y' || n.at(n.size() - 2) == 'Y' ||
n.at(n.size() - 2) == 'i' || n.at(n.size() - 2) == 'I')
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int p[100100], t[100100];
int id[100100], L[100100], R[100100], ans[100100];
bool cmp(int i, int j) { return R[i] < R[j]; }
struct RMQ_Tree {
int n;
int mx[1 << 20];
void init(int _n) {
for (n = 1; n < _n; n <<= 1)
;
for (int i = n << 1; --i;) mx[i] = 0;
}
void insert(int p, int val) {
p += n - 1;
for (; p && val > mx[p]; p >>= 1) mx[p] = val;
}
int calc(int st, int ed) {
if (st > ed) return 0;
st += n - 1;
ed += n;
int ans = 0;
while (st < ed) {
if (st & 1) smax(ans, mx[st++]);
if (ed & 1) smax(ans, mx[ed ^ 1]);
st >>= 1;
ed >>= 1;
}
return ans;
}
} Tree;
int find_root(int l, int r) {
if (l == r) return l;
int nr = Tree.calc(l, r);
if (r >= nr) return r;
return find_root(l, nr);
}
int main() {
int n, m, q;
gn(n, m);
Tree.init(n);
for (int i = 1; i <= n; i++) p[i] = i, t[i] = i;
for (int i = 0; i < m; i++) {
int first, second;
gn(first, second);
p[second] = first;
}
gn(q);
for (int i = 0; i < q; i++) {
gn(L[i], R[i]);
id[i] = i;
}
sort(id, id + q, cmp);
for (int i = 1, j = 0; i <= n; i++) {
Tree.insert(p[i], i);
smax(t[p[i]], i);
while (j < q && R[id[j]] == i) {
ans[id[j]] = find_root(L[id[j]], t[L[id[j]]]);
Tree.insert(L[id[j]], ans[id[j]]);
j++;
}
}
for (int i = 0; i < q; i++) println(ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
long long n, m, a[maxn], ans, d[maxn];
pair<long long, long long> b[maxn];
vector<long long> g[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
b[i] = make_pair(a[i], i);
}
for (long long i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
d[x] += a[y];
d[y] += a[x];
g[x].push_back(y);
g[y].push_back(x);
}
sort(b + 1, b + n + 1);
for (long long i = n; i >= 1; i--) {
long long x = b[i].second;
ans += d[x];
for (long long j = 0; j < g[x].size(); j++) d[g[x][j]] -= a[x];
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long Mode = 1e9 + 7;
void Modulo(unsigned long long &x) { x = ((x % Mode + Mode) % Mode); }
unsigned long long Pow(unsigned long long x, unsigned long long y) {
unsigned long long res = 1;
for (unsigned long long i = 0; (1ULL << i) <= y; i++, x *= x, Modulo(x))
if (y & (1ULL << i)) res *= x, Modulo(res);
return res;
}
int main() {
unsigned long long n, ans = 1, D = 1;
cin >> n;
D = n;
for (unsigned long long i = 2ULL * n - 1; i > 0; i--) ans *= i, Modulo(ans);
for (unsigned long long i = 1; i <= n - 1; i++) D *= i * i, Modulo(D);
ans *= Pow(D, Mode - 2);
ans *= 2ULL;
Modulo(ans);
ans -= n;
Modulo(ans);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
char str1[1001], str2[1001];
int main() {
gets(str1);
gets(str2);
int len1 = strlen(str1);
int len2 = strlen(str2);
int cnt1 = 0, cnt2 = 0;
int i;
for (i = 0; i < len1; i++)
if (str1[i] == '1') cnt1++;
for (i = 0; i < len2; i++)
if (str2[i] == '1') cnt2++;
if (cnt1 & 1) cnt1++;
if (cnt1 >= cnt2)
puts("YES");
else
puts("NO");
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int a[200005],n;
bool b[200005];
inline bool pd(int x){
for(int i=1;i<=n*2-1;i++)
b[i]=(a[i]>=x);
b[0]=b[1];
for(int i=n;i<=n+n-1;i++){
if(b[i]==b[i+1]) return b[i];
if(b[n+n-i]==b[n+n-i-1]) return b[n+n-i];
}
return b[1];
}
int main(int argc, char** argv) {
cin >> n;
for(int i=1;i<=n*2-1;i++) cin >> a[i];
int l=1,r=n*2,ans=0;
while(l<=r){
int md=(l+r)/2;
if(pd(md))
l=md+1,ans=max(ans,md);
else
r=md-1;
}
cout << ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
int n;
int cnt, first[200010];
struct edge {
int v, nx;
} o[500010];
void add(int u, int v) { o[++cnt].v = v, o[cnt].nx = first[u], first[u] = cnt; }
int f[200010], du[200010], size[200010], fac[200010];
void dfs(int x, int fa) {
f[x] = size[x] = 1;
du[x] = 0;
for (int i = first[x]; i; i = o[i].nx)
if (o[i].v != fa) {
dfs(o[i].v, x);
++du[x];
size[x] += size[o[i].v];
f[x] = 1ll * f[x] * f[o[i].v] % 998244353 * du[x] % 998244353 *
(du[o[i].v] + 1) % 998244353;
}
}
int main() {
scanf("%d", &n);
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1LL * fac[i - 1] * i % 998244353;
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 1);
printf("%I64d\n", 1ll * f[1] * n % 998244353);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long m, ans, a[110], k;
long long Div(long long x, long long y) { return (x + y - 1) / y; }
int main() {
long long i, last, sum, cnt;
int j;
scanf("%d%I64d", &n, &k);
for (j = 1; j <= n; j++) scanf("%I64d", &a[j]), m = max(m, a[j] + k);
for (i = m; i; i = last - 1) {
for (last = 1, j = 1; j <= n; j++)
last = max(last, Div(a[j], Div(a[j], i)));
for (sum = cnt = 0, j = 1; j <= n; j++)
sum += (last - a[j] % last) % last, cnt += Div(a[j], last);
if (sum <= k) {
printf("%I64d\n", last + (k - sum) / cnt);
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
if (s.find('B') == -1)
cout << 0;
else {
int a[100] = {0}, k = 0, l = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'B')
k++;
else if (s[i - 1] == 'B') {
a[l++] = k;
k = 0;
}
if (i == s.length() - 1 && s[i] == 'B') a[l++] = k;
}
cout << l << "\n";
for (int i = 0; i < l; i++) cout << a[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int ui;
typedef long long ll;
typedef unsigned long long ull;
constexpr int MAXN = 400;
ll dp[MAXN + 2][MAXN + 2];
ll a[MAXN + 2];
int main() {
int N;
cin >> N;
for(int i = 1; i <= N; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for(int i = 2; i <= N; i++) {
for(int j = 0; i + j <= N; j++) {
dp[i][j] = LONG_MAX;
for(int k = 1; k < i; k++)
dp[i][j] = min(dp[i][j], dp[i - k][j] + dp[k][i + j - k]);
dp[i][j] += a[i + j] - a[j];
}
}
cout << dp[N][0] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
int main() {
cin >> a >> b;
if (b == 10 && a == 1)
cout << -1;
else {
if (b == 10) {
for (n = 1; n < a; n++) cout << 1;
cout << 0;
} else
for (n = 1; n <= a; n++) cout << b;
}
cout << endl;
}
| 1 |
#include <cstdio>
int main(int argc, char *argv[]) {
int sum;
while (true) {
fscanf(stdin, "%d", &sum);
if (sum==0) break;
int tmp, hits=0;
for (int i = 0; i < sum/4; i++) {
scanf("%d", &tmp);
hits+=tmp;
}
printf("%d\n", hits);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int n7 = 1201234;
const long long mo = 998244353;
int n, m, a[n7];
long long g[n7];
int rd() {
int shu = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) shu = (shu << 1) + (shu << 3) + (ch ^ 48), ch = getchar();
return shu;
}
long long Dpow(long long p, long long q) {
long long tot = 1;
while (q) {
if (q & 1) tot = tot * p % mo;
p = p * p % mo, q = q >> 1;
}
return tot;
}
namespace POLY {
const int q7 = n7;
long long ori1[q7], ori2[q7], rv[q7];
long long Dpow(long long p, long long q) {
long long tot = 1;
while (q) {
if (q & 1) tot = tot * p % mo;
p = p * p % mo, q = q >> 1;
}
return tot;
}
void Tpre(int n) {
long long inv = Dpow(3, mo - 2);
for (int len = 2; len <= n + 1; len = len << 1) {
ori1[len] = Dpow(3, (mo - 1) / len);
ori2[len] = Dpow(inv, (mo - 1) / len);
}
}
void Trev(int n) {
for (int i = 0; i <= n; ++i) {
rv[i] = (rv[i >> 1] >> 1);
if (i & 1) rv[i] = rv[i] | ((n + 1) >> 1);
}
}
int totwo(int x) {
int z = 1;
while (z <= x) z = z << 1;
return z;
}
void NTT(long long *f, int n, bool sys) {
for (int i = 0; i <= n; ++i) {
if (i < rv[i]) swap(f[i], f[rv[i]]);
}
for (int len = 1; len < n + 1; len = len << 1) {
int far = len << 1;
long long ori = sys ? ori2[far] : ori1[far];
for (int i = 0; i <= n; i = i + far) {
long long z = 1;
for (int j = i; j <= i + len - 1; ++j) {
long long tmp = z * f[len + j] % mo;
f[len + j] = (f[j] - tmp + mo) % mo;
f[j] = (f[j] + tmp) % mo;
z = z * ori % mo;
}
}
}
if (sys) {
long long inv = Dpow(n + 1, mo - 2);
for (int i = 0; i <= n; ++i) f[i] = f[i] * inv % mo;
}
}
void Tmul(long long *f, long long *g, int n) {
Trev(n);
NTT(f, n, 0), NTT(g, n, 0);
for (int i = 0; i <= n; ++i) f[i] = f[i] * g[i] % mo;
NTT(f, n, 1);
}
void Tmulz(long long *f, long long *g, long long *S, int n) {
const int p7 = (n << 1) + 10;
long long A[p7], B[p7];
memset(A, 0, sizeof A), memset(B, 0, sizeof B);
for (int i = 0; i <= n; ++i) A[i] = f[i], B[i] = g[i];
Trev(n);
NTT(A, n, 0), NTT(B, n, 0);
for (int i = 0; i <= n; ++i) A[i] = A[i] * B[i] % mo;
NTT(A, n, 1);
for (int i = 0; i <= n; ++i) S[i] = A[i];
}
void Tinv(long long *f, long long *S, int n) {
const int p7 = (n << 1) + 10;
long long s[p7], A[p7], B[p7];
memset(A, 0, sizeof A), memset(B, 0, sizeof B), memset(s, 0, sizeof s);
s[0] = Dpow(f[0], mo - 2);
for (int len = 2; len <= n + 1; len = len << 1) {
int far = (len << 1) - 1;
for (int i = 0; i <= len - 1; ++i) A[i] = f[i], B[i] = s[i];
Trev(far);
NTT(A, far, 0), NTT(B, far, 0);
for (int i = 0; i <= far; ++i)
s[i] = (B[i] * 2 % mo - A[i] * B[i] % mo * B[i] % mo + mo) % mo;
NTT(s, far, 1);
for (int i = len; i <= far; ++i) s[i] = 0;
}
for (int i = 0; i <= n; ++i) S[i] = s[i];
}
void Tderiv(long long *f, long long *S, int n) {
const int p7 = (n) + 10;
long long s[p7];
s[n] = 0;
for (int i = 1; i <= n; ++i) s[i - 1] = f[i] * i % mo;
for (int i = 0; i <= n; ++i) S[i] = s[i];
}
void Tint(long long *f, long long *S, int n) {
const int p7 = (n) + 10;
long long s[p7];
s[0] = 0;
for (int i = 0; i <= n - 1; ++i) s[i + 1] = f[i] * Dpow(i + 1, mo - 2) % mo;
for (int i = 0; i <= n; ++i) S[i] = s[i];
}
void Tln(long long *f, long long *S, int n) {
const int p7 = (n << 1) + 10;
long long A[p7], B[p7];
memset(A, 0, sizeof A), memset(B, 0, sizeof B);
for (int i = 0; i <= n; ++i) A[i] = f[i];
Tderiv(A, B, n);
Tinv(A, A, n);
Tmul(A, B, n + n + 1);
Tint(A, A, n);
for (int i = 0; i <= n; ++i) S[i] = A[i];
}
void Texp(long long *f, long long *S, int n) {
const int p7 = (n << 1) + 10;
long long s[p7], A[p7], B[p7], C[p7];
memset(A, 0, sizeof A), memset(B, 0, sizeof B), memset(C, 0, sizeof C),
memset(s, 0, sizeof s);
s[0] = 1;
for (int len = 2; len <= n + 1; len = len << 1) {
int far = (len << 1) - 1;
for (int i = 0; i <= len - 1; ++i) A[i] = f[i], B[i] = s[i];
Tln(B, C, len - 1);
for (int i = 0; i <= len - 1; ++i) C[i] = (A[i] - C[i] + mo) % mo;
C[0] = (C[0] + 1) % mo;
Trev(far);
NTT(B, far, 0), NTT(C, far, 0);
for (int i = 0; i <= far; ++i) s[i] = B[i] * C[i] % mo;
NTT(s, far, 1);
for (int i = len; i <= far; ++i) s[i] = 0;
}
for (int i = 0; i <= n; ++i) S[i] = s[i];
}
void Tsqrt(long long *f, long long *S, int n) {
const int p7 = (n << 1) + 10;
long long s[p7], A[p7], B[p7], C[p7];
memset(A, 0, sizeof A), memset(B, 0, sizeof B), memset(C, 0, sizeof C),
memset(s, 0, sizeof s);
s[0] = 1;
long long inv = Dpow(2, mo - 2);
for (int len = 1; len <= n + 1; len = len << 1) {
int far = (len << 1) - 1;
for (int i = 0; i <= len - 1; ++i) A[i] = f[i], B[i] = s[i];
Tinv(B, C, len - 1);
Trev(far);
NTT(A, far, 0), NTT(C, far, 0);
for (int i = 0; i <= far; ++i) s[i] = A[i] * C[i] % mo;
NTT(s, far, 1);
for (int i = 0; i <= len - 1; ++i) s[i] = (s[i] + B[i]) % mo * inv % mo;
for (int i = len; i <= far; ++i) s[i] = 0;
}
for (int i = 0; i <= n; ++i) S[i] = s[i];
}
void Tpow(long long *f, long long *S, int n, long long K) {
const int p7 = (n << 1) + 10;
long long s[p7];
memset(s, 0, sizeof s);
Tln(f, s, n);
for (int i = 0; i <= n; ++i) s[i] = s[i] * K % mo;
Texp(s, s, n);
for (int i = 0; i <= n; ++i) S[i] = s[i];
}
void Tturn(long long *f, int n) {
for (int i = 0; i <= n / 2; ++i) swap(f[i], f[n - i]);
}
void Tdiv(long long *f, long long *g, long long *S, long long *Syu, int n,
int m) {
const int p7 = ((n + m) << 2) + 10;
long long A[p7], B[p7], s[p7], sz[p7], syu[p7];
memset(A, 0, sizeof A), memset(B, 0, sizeof B), memset(s, 0, sizeof s),
memset(sz, 0, sizeof sz);
for (int i = 0; i <= n; ++i) A[i] = f[i];
for (int i = 0; i <= m; ++i) B[i] = g[i];
Tturn(A, n), Tturn(B, m);
int z1 = totwo(n - m + 1) - 1;
Tinv(B, B, z1);
int z2 = totwo(n + n - m + 1) - 1;
for (int i = n - m + 1; i <= z2; ++i) B[i] = 0;
Tmul(A, B, z2);
for (int i = 0; i <= n - m; ++i) s[i] = A[i];
Tturn(s, n - m);
for (int i = 0; i <= n - m; ++i) sz[i] = s[i];
int z3 = totwo(n + 1) - 1;
for (int i = 0; i <= m; ++i) B[i] = g[i];
for (int i = m + 1; i <= z3; ++i) B[i] = 0;
Tmul(B, s, z3);
for (int i = 0; i <= m; ++i) syu[i] = (f[i] - B[i] + mo) % mo;
for (int i = 0; i <= n - m; ++i) S[i] = sz[i];
for (int i = 0; i <= m; ++i) Syu[i] = syu[i];
}
} // namespace POLY
int main() {
n = rd(), m = rd();
for (int i = 1; i <= n; ++i) g[rd()] = mo - 4;
g[0] = 1;
int len = m;
m = POLY::totwo(m);
POLY::Tpre(m << 1);
POLY::Tsqrt(g, g, m);
g[0] = (g[0] + 1) % mo;
POLY::Tinv(g, g, m);
for (int i = 1; i <= len; ++i) printf("%lld\n", g[i] * 2 % mo);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int main(void)
{
int a,b,x;
int i,j;
cin>>a>>b>>x;
int mn=10000007;
for(i=0;i<=x/1000+1;i++){
for(j=0;j<=x/500+1;j++){
if(1000*i+500*j>=x && mn>a*i+b*j){
mn=a*i+b*j;
}
}
}
cout<<mn<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
long long p, k;
cin >> p >> k;
if (k == 0) {
long long res = 1;
for (long long i = 1; i < p; i++) {
res = (res * p) % mod;
}
cout << res << endl;
} else if (k == 1) {
long long res = 1;
for (long long i = 1; i <= p; i++) {
res = (res * p) % mod;
}
cout << res << endl;
} else {
int tmp = k;
int cnt = 1;
while (tmp != 1) cnt++, tmp = (tmp * k) % p;
tmp = (p - 1) / cnt;
long long res = 1;
for (int i = 0; i < tmp; i++) {
res = (res * p) % mod;
}
cout << res << endl;
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main(){
int n, l, a[100000] = {}, pre = 0;
long long int max = -1, sum = 0;
cin >> n >> l;
for(int i = 0;i<n;i++){
cin >> a[i];
a[i] = l - a[i];
}
pre = 0;
sum = 0;
for(int i = 0;i<n;i++){
if(pre < a[i]) {
pre = a[i];
sum = a[i];
}
else sum += a[i];
pre = a[i];
if(sum > max) max = sum;
}
pre = 0;
sum = 0;
for(int i = n-1;i>=0;i--){
if(pre < a[i]) {
pre = a[i];
sum = a[i];
}
else sum += a[i];
pre = a[i];
if(sum > max) max = sum;
}
cout << max << endl;
return 0;
} | 0 |
#include<iostream>
#include<cstring>
using namespace std;
int x[1180][118][118], n, m, p, a, b, c;
int main() {
while (true) {
memset(x, 0, sizeof(x));
cin >> n >> m >> p; if (!n) { break; }
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
x[a][b][c] = 1; x[a][c][b] = 1;
}
for (int i = 1000; i > 0; i--) {
for (int j = 1; j <= n; j++) {
if (x[i][p][j] == 1) {
p = j;
break;
}
}
}
cout << p << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int a[N][N];
int main() {
int n, m, k;
cin >> n >> m >> k;
int sum = 0, cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int j = 1; j <= m; j++) {
int maxscore = 0, one = 0, tt = 0;
for (int i = 1; i <= n; i++) {
if (a[i][j] == 0) continue;
int score = 0;
for (int l = i; l <= min(i + k - 1, n); l++) {
if (a[l][j]) score++;
}
if (score > maxscore) {
maxscore = score;
tt = one;
}
one++;
}
sum += maxscore;
cnt += tt;
}
cout << sum << ' ' << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
double a, b, p, first, c = 0.000000001, vas = -1;
double arv(double alfa) {
return ((b - (p * sin(alfa) - a) / tan(alfa)) * sin(alfa));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> a >> b >> p;
double L = 0, R = asin(1), al, ar;
double l = L + (R - L) / 3, r = L + 2 * (R - L) / 3;
int m = 0;
while (r - l > c) {
al = arv(l), ar = arv(r);
if (al < ar)
R = r;
else
L = l;
l = L + (R - L) / 3, r = L + 2 * (R - L) / 3;
m++;
}
if (p <= a) {
vas = min(p, b);
}
double vas1 = -1;
if (p <= b) {
vas1 = min(p, a);
}
vas = max(vas, vas1);
vas1 = min(p, al);
vas = max(vas, vas1);
if (vas <= 0)
cout << "My poor head =(";
else
cout << setprecision(10) << vas;
}
| 5 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
#define INF 1000000
using namespace std;
int main(){
int n,k,s;
while(cin >> n >> k >> s){
if(n == 0 && k == 0 && s == 0) break;
int dp[30][30][200]={};
for(int i=0; i<=n; i++) dp[i][0][0] = 1;
for(int i=1; i<=n; i++){
for(int j=1; j<=k; j++){
for(int l=0; l<=s; l++){
if(l < i) dp[i][j][l] = dp[i-1][j][l];
else dp[i][j][l] = dp[i-1][j][l] + dp[i-1][j-1][l-i];
}
}
}
cout << dp[n][k][s] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
string s;
int ans;
signed main(){
while (cin >> s && s > "0"){
ans = 0;
for (int i = 0; i < s.length(); i++){
ans += s[i] - '0';
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, m;
cin >> x >> y >> m;
bool is = false;
vector<vector<int>> v(x + 2, vector<int>(y + 2, 0));
for (int i = 0; i < m; i++) {
int xt, yt;
cin >> xt >> yt;
v[xt][yt] = 1;
if ((v[xt + 1][yt] == 1 && v[xt][yt + 1] == 1 && v[xt + 1][yt + 1] == 1) ||
(v[xt - 1][yt] == 1 && v[xt][yt + 1] == 1 && v[xt - 1][yt + 1] == 1) ||
(v[xt - 1][yt] == 1 && v[xt][yt - 1] == 1 && v[xt - 1][yt - 1] == 1) ||
(v[xt + 1][yt] == 1 && v[xt][yt - 1] == 1 && v[xt + 1][yt - 1] == 1)) {
cout << i + 1 << "\n";
return 0;
}
}
cout << 0 << "\n";
}
| 1 |
#include <iostream>
using namespace std;
double x[5], y[5];
bool check() {
double xa[3], ya[3], s[3];
bool in[2], b[3];
for (int i=0; i<3; i++) {
xa[i] = y[(i+1)%3] - y[i];
ya[i] = -x[(i+1)%3] + x[i];
s[i] = xa[i]*x[i] + ya[i]*y[i];
}
for (int i=0; i<2; i++) {
for (int j=0; j<3; j++) {
b[j] = (xa[j]*x[i+3] + ya[j]*y[i+3] < s[j]);
}
in[i] = (b[0] == b[1] && b[1] == b[2]);
}
return (in[0] != in[1]);
}
int main() {
int n;
cin >> n;
for (int i=0; i<n; i++) {
for (int j=0; j<5; j++) {
cin >> x[j] >> y[j];
}
if (check()) {
cout << "OK" << endl;
} else {
cout << "NG" << endl;
}
}
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.