code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
void print_array(int A[], int N) {
for(int i = 0; i < N-1; ++i) {
std::cout << A[i] << " ";
}
std::cout << A[N-1] << std::endl;
return;
}
int count;
void bubbleSort(int A[], int N) {
bool flag = true;
while( flag ) {
flag = false;
for(int j = N-1; j >= 1; --j) {
if( A[j] < A[j-1] ) {
std::swap(A[j], A[j-1]);
flag = true;
count += 1;
}
}
}
return;
}
int main(void) {
int N;
int A[128];
std::cin >> N;
for(int i = 0; i < N; ++i) {
std::cin >> A[i];
}
bubbleSort(A, N);
print_array(A, N);
std::cout << count << std::endl;
return 0;
} | #define LOCAL
#undef _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define LLINF 1e18
#define INF (int)1e9+1
// Copied from Gennady-Korotkevich's template
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string)s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}\n";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}\n";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
template <typename A, typename B, typename C, typename D, typename E>
string to_string(tuple<A, B, C, D, E> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + "," + to_string(get<4>(p)) + ")";
}
void debug_out() {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "\n[" << #__VA_ARGS__ << "]:\n", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// End of Gennady-Korotkevich's template
using llong = long long;
using PII = pair<int, int>;
const llong MOD = 998244353LL;
int main() {
IOS;
bool suc = true;
int n; cin >> n; set<int > a;
for (int i = 0; i < n; i++) {
int k; cin >> k;
if (a.count(k)) suc = false;
a.insert(k);
}
if (suc) cout << "YES";
else cout << "NO";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define int long long
#define endl "\n"
#define all(v) v.begin(),v.end()
#define double long double
#define trace1(x) cerr<<#x<<": "<<x<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<":" <<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define trace4(a, b, c, d) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl
#define trace5(a, b, c, d, e) cerr<<#a<<": "<<a<<" | "<<#b<< ": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<endl
#define trace6(a, b, c, d, e, f) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<" | "<<#f<<": "<<f<<endl
#define cases int testcases;cin>>testcases; while(testcases--)
const int N = 200005;
int dp[101][101];
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS
string s;
cin >> s;
set<char> ss(s.begin(),s.end());
for(int i = 0; i < 26; i++)
{
char ch = 'a' + i;
if(!ss.count(ch))
{
cout << ch;
return 0;
}
}
cout << "None";
return 0;
}
| #include <cstdio>
char S[101010];
int main()
{
scanf("%s", S);
bool app[26];
for (int i = 0; i < 26; ++i) {
app[i] = false;
}
for (int i = 0; S[i] != '\0'; ++i) {
app[S[i] - 'a'] = true;
}
for (int i = 0; i < 26; ++i) {
if (!app[i]) {
printf("%c\n", (char)(i + 'a'));
return 0;
}
}
puts("None");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int H, W;
cin >> H >> W;
vector<vector<int>> S(H);
for(int i=0; i<H; i++){
string s;
cin >> s;
for(int j=0; j<W; j++) S[i].push_back(s[j] == '#');
}
int ans = max(H, W);
vector<int> h(W);
for(int i=0; i<H; i++){
stack<pair<int, int>> st;
for(int j=0; j<W; j++){
int pos = j;
while(st.size() && st.top().first > h[j]){
auto& p = st.top();
int res = (p.first+1) * (j-p.second+1);
ans = max(ans, res);
pos = p.second;
st.pop();
}
if(st.size() == 0 || st.top().first < h[j]) st.push({h[j], pos});
}
if(i<H-1) for(int j=0; j<W-1; j++){
if((S[i][j] + S[i+1][j] + S[i][j+1] + S[i+1][j+1]) % 2){
h[j] = 0;
}else{
h[j]++;
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
static const long long INF=1000000000000000000;
int main(){
long long N;
long long K;
cin>>N>>K;
long long X[N];
for(long long i=0;i<N;i++){
cin>>X[i];
}
long long ans=INF;
for(long long i=0;i<N-K+1;i++){
ans=min(ans,abs(X[i])+abs(X[i]-X[i+K-1]));
ans=min(ans,abs(X[i+K-1])+abs(X[i]-X[i+K-1]));
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int min(int a, int b, int c) {
if (a < b) {
if (a < c) {
return a;
} else {
return c;
}
} else {
if (b < c) {
return b;
} else {
return c;
}
}
}
int level(int j, int o, int i) {
int c = min(j, o, i);
if (c == o) return c;
else return 0;
}
int main() {
string s; cin >> s;
int j_count = 0, o_count = 0, i_count = 0;
int count = 0;
char state = 'f'; // f: first, J: J, O: O, I: I
for (string::iterator p = s.begin(); p != s.end(); p++) {
switch (state) {
case 'f':
if (*p == 'J') {
j_count = 1;
state = 'J';
}
break;
case 'J':
if (*p == 'J') {
j_count++;
} else if (*p == 'O') {
o_count = 1;
state = 'O';
} else {
j_count = 0;
o_count = 0;
i_count = 0;
state = 'f';
}
break;
case 'O':
if (*p == 'O') {
o_count++;
} else if(*p == 'I') {
i_count = 1;
state = 'I';
if (p == s.end()-1) {
int _count = level(j_count, o_count, i_count);
if (count < _count) {
count = _count;
}
}
} else {
if (*p == 'J') {
j_count = 1;
o_count = 0;
i_count = 0;
state = 'J';
} else {
j_count = 0;
o_count = 0;
i_count = 0;
state = 'f';
}
}
break;
case 'I':
if (*p == 'I') {
i_count++;
if (p == s.end()-1) {
int _count = level(j_count, o_count, i_count);
if (count < _count) {
count = _count;
}
}
}
if (*p != 'I') {
int _count = level(j_count, o_count, i_count);
if (count < _count) {
count = _count;
}
if (*p == 'J') {
state = 'J';
j_count = 1;
o_count = 0;
i_count = 0;
} else {
state = 'f';
j_count = 0;
o_count = 0;
i_count = 0;
}
}
break;
}
}
cout << count << endl;
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <functional>
#include <bitset>
#include <numeric>
#include <complex>
#include <iomanip>
#include <cassert>
#include <random>
int main() {
std::string s; std::cin >> s;
int n = s.size();
if (n & 1) {
std::cout << "No" << std::endl;
return 0;
}
for (int i = 0; i < n - 1; i += 2) {
if (s[i] != 'h' || s[i + 1] != 'i') {
std::cout << "No" << std::endl;
return 0;
}
}
std::cout << "Yes" << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define sz(x) (int)x.size()
#define pb push_back
#define mp make_pair
#define fi(a, b) for(int i=a; i<=b; i++)
#define fj(a, b) for(int j=a; j<=b; j++)
#define fo(a, b) for(int o=a; o<=b; o++)
#define fdi(a, b) for(int i=a; i>=b; i--)
#define fdj(a, b) for(int j=a; j>=b; j--)
#define fdo(a, b) for(int o=a; o>=b; o--)
#ifdef LOCAL
#define err(...) fprintf(stderr, __VA_ARGS__)
#else
#define err(...) while(false) {}
#endif
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef long double ld;
typedef unsigned long long ull;
/////////////////////////////////
int const MAX = 15;
int n, m;
int e[MAX][MAX];
int d1[(1 << MAX)];
int d2[(1 << MAX)][MAX];
bool bit(int m, int i) {
return (1 & (m >> i));
}
void init() {
for (int mask = 0; mask < (1 << n); mask++) {
fi(0, n - 1) {
fj(i + 1, n - 1) {
if (bit(mask, i) && bit(mask, j)) {
d1[mask] += e[i][j];
}
}
}
}
for (int mask = 0; mask < (1 << n); mask++) {
fo(0, n - 1) {
fi(0, n - 1) {
if (bit(mask, i)) {
d2[mask][o] += e[i][o];
}
}
}
}
}
int d[(1 << MAX)][MAX];
int const INF = 1e9 + 41;
int ans;
int sum;
int getbest(int comp, int path) {
int res = 0;
fi(0, n - 1) {
if (bit(path, i)) {
res = max(res, d2[comp][i]);
}
}
res += d1[comp];
return res;
}
void solve() {
init();
for (int mask = 0; mask < (1 << n); mask++) {
fo(0, n - 1) {
d[mask][o] = -INF;
}
}
d[(1 << (n - 1)) - 1][n - 1] = 0;
for (int mask = (1 << n) - 1; mask > 0; mask--) {
fo(0, n - 1) {
if (d[mask][o] < 0) continue;
fi(0, n - 1) {
if (e[i][o] && bit(mask, i)) {
int nmask = (mask ^ (1 << i));
d[nmask][i] = max(d[nmask][i], d[mask][o] + e[i][o]);
}
}
int sm = mask;
while (sm > 0) {
int nmask = (mask ^ sm);
int pathmask = ( ((1 << n) - 1) ^ mask);
int bs = getbest(sm, pathmask);
d[nmask][o] = max(d[nmask][o], d[mask][o] + bs);
sm = ((sm - 1) & mask);
}
}
}
ans = sum - d[0][0];
err("d = %d sum = %d\n", d[0][0], sum);
printf("%d\n", ans);
}
int main() {
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
scanf("%d %d", &n, &m);
fi(1, m) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
x--;
y--;
e[x][y] = e[y][x] = w;
sum += w;
}
solve();
#ifdef LOCAL
err("ELAPSED TIME: %.3Lf\n", (ld) clock() / CLOCKS_PER_SEC);
#endif
return 0;
} | #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
typedef pair < int, int > pii;
const int N = 16;
const int M = (1 << N);
const int INF = 0x3f3f3f3f;
int dp[N][M], g[N][N], n, m, rv[M];
int f(int st, int msk){
if(st == n - 1) return 0;
if(dp[st][msk] != -1) return dp[st][msk];
int sol = INF;
for(int msk1 = (msk - 1) & msk; msk1 ; msk1 = (msk1 - 1) & msk){
int msk2 = msk ^ msk1;
if(msk1 & (1 << (n - 1))) continue;
if(msk2 & (1 << st)) continue;
int sum = 0;
for(int t1 = msk1; t1 ; t1 -= t1 & (-t1)){
for(int t2 = msk2 ; t2 ; t2 -= t2 & (-t2)){
sum += g[rv[t1 & (-t1)]][rv[t2 & (-t2)]];
}
}
for(int t2 = msk2 ; t2 ; t2 -= t2 & (-t2)){
if(g[st][rv[t2 & (-t2)]]){
sol = min(sol, f(rv[t2 & (-t2)], msk2) + sum - g[st][rv[t2 & (-t2)]]);
}
}
}
return dp[st][msk] = sol;
}
int main(){
memset(dp, -1, sizeof(dp));
for(int i = 0;i<N;i++) rv[(1 << i)] = i;
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
for(int i = 0;i<m;i++){
int x, y;scanf("%d%d", &x, &y);x--;y--;
scanf("%d", &g[x][y]);
g[y][x] = g[x][y];
}
printf("%d\n", f(0, (1 << n) - 1));
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
using namespace std;
int main() {
int N;
int A[8], B[8];
int NUM[8];
double sum = 0;
cin >> N;
rep(i, N) {
cin >> A[i] >> B[i];
}
rep(i, N) NUM[i] = i;
do {
rep(i, N-1) {
sum += sqrt(pow(A[NUM[i+1]]-A[NUM[i]], 2)
+ pow(B[NUM[i+1]]-B[NUM[i]], 2));
}
} while(next_permutation(NUM, NUM+N));
rep(i, N) sum /= (i+1);
cout << fixed << setprecision(10) << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define rrng(a) a.rbegin(), a.rend()
#define maxs(x, y) (x = max(x, y))
#define mins(x, y) (x = min(x, y))
#define limit(x, l, r) max(l, min(x, r))
#define lims(x, l, r) (x = max(l, min(x, r)))
#define isin(x, l, r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define print(x) cout << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T> >
#define bn(x) ((1 << x) - 1)
#define dup(x, y) (((x) + (y)-1) / (y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
int main() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
rep(i,n+1){
string ans = s.substr(0,i)+t;
if(ans.substr(0,n) == s){
cout<<sz(ans)<<endl;
return 0;
}
}
return 0;
} | 0 |
#include <vector>
#include <iostream>
using namespace std;
int main()
{
int n; cin >> n;
vector<int> v(n);
for(auto &x : v) cin >> x;
for(auto it = v.crbegin(); it != v.crend(); ++it)
cout << *it << (((it+1)==v.crend()? "" : " "));
cout << endl;
return 0;
}
| // This template belongs to Juan Carlo Vieri
/* ____ __
/ _/ | | __ __
__| |__ | | /_/ | |
|__ __| | | __ ____ | | __ ___ _ ___
| | | | | | / _/ | |/ / / _ \ | |/ _/
| | | | | | | |_ | \ | __/ | /
|__| |__| |__| \___\ |__|\__\ \___\ |__|
*/
#include <bits/stdc++.h>
using namespace std;
typedef int_fast64_t ll;
typedef long double ld;
typedef int_fast64_t intt;
typedef int_fast32_t tmp_m;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#define from(x, y, arr) (arr[y] - ((x > 0) ? (arr[x - 1]) : (0)))
#define min(a, b) (a > b ? b : a)
#define max(a, b) (a < b ? b : a)
#define puts(x) cout << x << endl
#define deb(x) cout << #x << ' ' << x << endl
#define rep(i, cmp1, cmp2) for (tmp_m i = (tmp_m)cmp1; i < (tmp_m)cmp2; ++i)
#define repp(i, cmp1, cmp2) for (tmp_m i = (tmp_m)cmp1; i >= (tmp_m)cmp2; --i)
#define pb push_back
#define st stack
#define pa pair
#define vc vector
#define qu queue
#define pq priority_queue
#define fr first
#define sc second
#define mp map
const ld pi = acos(-1.0);
const intt mod = 1e9 + 7;
struct pr {
intt x;
intt y;
intt dst;
pr() {}
pr(intt x, intt y, intt dst) : x(x), y(y), dst(dst) {}
inline bool operator<(const pr& cmp2) const {
if (dst != cmp2.dst) return dst < cmp2.dst;
if (x != cmp2.x) return x < cmp2.x;
return y < cmp2.y;
}
inline bool operator==(const pr& cmp2) const {
return (cmp2.dst == dst) && (cmp2.x == x) && (cmp2.y == y);
}
inline bool operator>(const pr& cmp2) const {
if (dst != cmp2.dst) return dst > cmp2.dst;
if (x != cmp2.x) return x > cmp2.x;
return y > cmp2.y;
}
};
struct point {
intt x;
intt y;
point() {}
point(intt x, intt y) : x(x), y(y) {}
inline bool operator<(const point& cmp2) const {
if (cmp2.x != x) return cmp2.x < x;
return cmp2.y < y;
}
inline bool operator==(const point& cmp2) const {
return (cmp2.x == x) && (cmp2.y == y);
}
inline bool operator>(const point& cmp2) const {
if (cmp2.x != x) return cmp2.x > x;
return cmp2.y > y;
}
};
namespace std {
template<typename T>
struct hash<vector<T> > {
size_t operator()(const vector<T>& k) const {
size_t ret = 0xf3ee477d;
for (size_t i = 0; i != k.size(); ++ i)
ret ^= hash(hash(k[i]) + i);
return ret;
}
};
template<>
struct hash<pr>{
size_t operator()(const pr& cmp1) const {
return (hash<intt>()(cmp1.x)) ^ (hash<intt>()(cmp1.y)) ^
(hash<intt>()(cmp1.dst));
}
};
template<>
struct hash<point>{
size_t operator()(const point& cmp1) const {
return (hash<intt>()(cmp1.x)) ^ (hash<intt>()(cmp1.y));
}
};
}
inline bool spoint(const point& cmp1, const point& cmp2) {
// swap(cmp1, cmp2);
if (cmp1.x != cmp2.x) return cmp1.x < cmp2.x;
return cmp1.y < cmp2.y;
}
inline bool spr(const pr& cmp1, const pr& cmp2) {
// swap(cmp1, cmp2);
if (cmp1.dst != cmp2.dst) return cmp1.dst < cmp2.dst;
if (cmp1.x != cmp2.x) return cmp1.x < cmp2.x;
return cmp1.y < cmp2.y;
}
void sub() {
}
void solve() {
// intt t; cin >> t;
// while (t--) sub();
intt n;
cin >> n;
vc<intt> arr(n);
intt nol = 0;
intt neg = 0;
rep(i, 0, n){
cin >> arr[i];
if(arr[i] == 0)nol = 1;
if(arr[i] < 0)++neg;;
}
if(neg % 2 == 0 || nol){
intt ans = 0;
rep(i, 0, n){
ans += abs(arr[i]);
}
cout << ans << endl;
return;
} else{
rep(i, 0, n){
arr[i] = abs(arr[i]);
}
sort(arr.begin(), arr.end());
intt ans = -(arr[0]);
rep( i, 1, n){
ans += arr[i];
}
cout << ans << endl;
}
}
void init() {
// remove if interactive
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
srand(time(0));
// memset(dp, -1, sizeof dp);
}
int main() {
init();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#if ((_WIN32 || __WIN32__) && __cplusplus < 201103L)
#define lld I64d
#else
#define lld lld
#endif
//{{{
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define clr(a, b) memset(a, b, sizeof(a))
// clang-format off
#define debug(args...) {vector<string> _v = split(#args, ','); err(_v.begin(), args); cerr<<endl;}
vector<string> split(const string& s, char c) {vector<string> v; stringstream ss(s); string x; while
(getline(ss, x, c)) v.push_back(x); return v;} void err(vector<string>::iterator) {}
template<typename T, typename... Args> void err(vector<string>::iterator it, T a, Args... args)
{cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << ", "; err(++it, args...);}
// clang-format on
//}}}
int a[22][22];
int n;
LL dp[1 << 16];
LL val[1 << 16];
LL dfs(int st)
{
if (dp[st] != -1) return dp[st];
if (__builtin_popcount(st) == 1) return dp[st] = 0;
LL ret = val[st];
for (int i = st; i; i = (i - 1) & st)
{
if (i == st) continue;
int st1 = i;
int st2 = st ^ i;
LL v = dfs(st1) + dfs(st2);
if (v > ret) ret = v;
}
return dp[st] = ret;
}
int main()
{
#ifdef LOCAL
freopen("in", "r", stdin);
// freopen("out", "w", stdout);
#endif
while (cin >> n)
{
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
int lim = (1 << n) - 1;
for (int st = 0; st <= lim; st++)
{
LL v = 0;
for (int i = 0; i < n; i++)
{
if ((st & (1 << i)) == 0) continue;
for (int j = i + 1; j < n; j++)
{
if ((st & (1 << j)) == 0) continue;
v += a[i][j];
}
}
val[st] = v;
}
clr(dp, -1);
dp[0] = 0;
LL ans = dfs(lim);
cout << ans << endl;
}
return 0;
}
| #include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
int main(){
int n,dum;
vector<int> p;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&dum);
p.push_back(dum);
}
sort(p.begin(),p.end());
if(n==2){
for(int i=1;i<=p[0];i++){
if(p[0]%i==0&&p[1]%i==0)
printf("%d\n",i);
}
}
else{
for(int i=1;i<=p[0];i++){
if(p[0]%i==0&&p[1]%i==0&&p[2]%i==0)
printf("%d\n",i);
}
}
}
| 0 |
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <cstring>
#include <chrono>
#include <vector>
#include <map>
#include <random>
#include <set>
#include <algorithm>
#include <math.h>
#include <cstdio>
#include <stdio.h>
#include <queue>
#include <bitset>
#include <cstdlib>
#include <deque>
#include <cassert>
#include <stack>
using namespace std;
#define mp make_pair
#define f first
#define se second
#define pb push_back
#define ppb pop_back
#define emb emplace_back
#define ll long long
#define ull unsigned long long
#define cntbit(x) __builtin_popcount(x)
#define endl '\n'
#define uset unordered_set
#define umap unordered_map
#define pii pair<int, int>
#define ld long double
#define pll pair<long long, long long>
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T> inline T range(T l, T r) {
return uniform_int_distribution<T>(l, r)(rng);
}
inline void setin(string s) {
freopen(s.c_str(), "r", stdin);
}
inline void setout(string s) {
freopen(s.c_str(), "w", stdout);
}
template <typename T> void Min(T &a, T b) {
a = min(a, b);
}
template <typename T> void Max(T &a, T b) {
a = max(a, b);
}
const int inf = 0x3f3f3f3f;
const int mod = 998244353;
const int N = 3e2 + 15;
int n, k;
string s;
int dp[2][N][N]; // dp[i][operation_applied][free_ones]
int a[N], p[N][N];
inline int add(int a, int b) {
a += b;
if(a >= mod)
a -= mod;
if(a < 0)
a += mod;
return a;
}
inline void add_t(int &a, int b) {
a = add(a, b);
}
inline void construct() {
int sz = 1;
for(int i = 1; i <= n && s[i] == '1'; ++i)
a[1] = i;
for(int i = a[1] + 1; i <= n; ++i) {
if(s[i] == '0') {
if(i + 1 <= n && s[i + 1] == '0')
a[++sz] = 0;
}
else {
int j = i;
while(j + 1 <= n && s[j + 1] == '1')
++j;
a[++sz] = j - i + 1;
i = j;
}
}
n = sz;
}
inline void solve() {
// dp[i][operation_applied][free_ones]
dp[(n + 1) & 1][0][0] = 1;
int sum = 0;
for(int i = n; i >= 1; --i) {
int bit = i & 1;
memset(dp[bit], 0, sizeof(dp[bit]));
for(int k = 0; k < N; ++k)
for(int t = 0; t < N; ++t)
p[k][t] = add(k && t ? p[k-1][t-1] : 0, dp[bit ^ 1][k][t]);
for(int k = 0; k < N; ++k) {
int val = 0;
for(int t = N - 1; t >= 0; --t) {
add_t(dp[bit][k][t], val);
if(k - a[i] - 1 >= 0 && t - a[i] - 1 >= 0)
add_t(dp[bit][k][t], add(p[k][t], -p[k - a[i] - 1][t - a[i] - 1]));
else
add_t(dp[bit][k][t], p[k][t]);
add_t(val, dp[bit ^ 1][k][t]);
}
}
sum += a[i];
}
}
inline void output() {
int ans = 0;
for(int i = 0; i < min(N, k + 1); ++i)
add_t(ans, dp[1][i][0]);
cout << ans << endl;
}
main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// setin("input.txt");
cin >> s >> k;
n = s.size();
s = '#' + s;
construct();
solve();
output();
return 0;
} | #include<iostream>
using namespace std;
int N;
string s;
long mod=1e9+7;
main()
{
cin>>N>>s;
long ans=1,cnt=0;
for(int i=0;i<2*N;i++)
{
if(cnt%2==0)
{
if(s[i]=='B')
{
cnt++;
}
else
{
ans=ans*cnt--%mod;
}
}
else
{
if(s[i]=='B')
{
ans=ans*cnt--%mod;
}
else
{
cnt++;
}
}
}
for(int i=1;i<=N;i++)ans=ans*i%mod;
cout<<(cnt==0?ans:0)<<endl;
}
| 0 |
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (int)n; ++i)
#define rrep(i, j, n) for (int i = (int)n - 1; j <= i; --i)
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T>& a) {
os << "{";
for (size_t i = 0; i < a.size(); ++i) os << (i > 0 ? "," : "") << a[i];
return os << "}";
}
constexpr ll MOD = 1000000007;
constexpr int INF = 0x3f3f3f3f;
constexpr ll INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename C>
ostream& operator<<(ostream& os, const multiset<T, C>& v) {
os << '{';
for (auto it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
os << '}';
return os;
}
template <typename T1, typename T2, typename C>
ostream& operator<<(ostream& os, const map<T1, T2, C>& mp) {
os << '[';
for (auto it = mp.begin(); it != mp.end(); it++) {
if (it != mp.begin()) os << ", ";
os << it->first << ": " << it->second;
}
os << ']';
return os;
}
int main() {
int h, w;
cin >> h >> w;
// 右へ動く最小値を保管
// ある点から始まった場合、
// 複数の最短経路結果を持ちたい。
//
map<int, int> mp;
multiset<int> st;
rep(i, 0, w) {
mp[i] = i;
st.insert(0);
}
rep(i, 0, h) {
int a, b;
cin >> a >> b;
--a;
// [a, b]はいけない
auto itr = mp.lower_bound(a);
int most_right = -1;
while (itr != mp.end() && itr->first <= b) {
most_right = max(most_right, itr->second);
int x = itr->first - itr->second;
st.erase(st.find(x));
itr = mp.erase(itr);
}
if (most_right != -1 && b < w) {
st.insert(b - most_right);
mp[b] = most_right;
}
if (st.size() > 0)
cout << *st.begin() + i + 1 << '\n';
else
cout << -1 << '\n';
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double pi=3.141592653589793;
typedef unsigned long long ull;
typedef long double ldouble;
const ll INF=1e18;
int main(){
ll d, g;
ll min = INF;
cin >> d >> g;
vector<ll> p(d);
vector<ll> c(d);
for(int i = 0; i < d; i++) {
cin >> p.at(i) >> c.at(i);
}
// {0, 1, ..., n-1} の部分集合の全探索
for (int bit = 0; bit < (1<<d); ++bit)
{
int max_index = -1;
ll score = 0, problem = 0;
/* bit で表される集合の処理を書く */
bitset<10> tmp(bit);
/* bit で表される集合の処理を書く */
for(int i = 0; i < d; i++){
if(tmp.test(i)) {
score += p.at(i) * (i+1) * 100 + c.at(i);
problem += p.at(i);
}
else max_index = i;
}
if(problem > min) continue;
if(score == 0){
while(score < g) {
problem++;
score += (max_index + 1) * 100;
if(problem > p.at(max_index)) {
problem = INF;
break;
}
}
}
else if(g > score && g - score < p.at(max_index) * 100 * (max_index+1)) {
problem += (g - score) / (max_index+1) / 100;
}
else if(g > score) continue;
if(problem < min) min = problem;
}
cout << min << endl;
} | 0 |
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include <map>
#include <fstream>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <assert.h>
#include <complex>
#include <omp.h>
using namespace std;
#define eps 0.000001
#define LONG_INF 100000000000000
#define GOLD 1.61803398874989484820458
#define seg_size 65536*4
#define REP(i,n) for(long long i = 0;i < n;++i)
unsigned long xor128() {
static unsigned long x = time(NULL), y = 362436069, z = 521288629, w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
vector<vector<pair<int, int>>> vertexs;
vector<pair<int, int>> unioning[1000001];
pair<int, int> union_tree[10000001];
int union_find(int now) {
if (union_tree[now].first == now) return now;
return union_tree[now].first = union_find(union_tree[now].first);
}
int union_merge(int a, int b) {
a = union_find(a);
b = union_find(b);
union_tree[b].second += union_tree[a].second;
union_tree[a].first = union_tree[b].first;
union_tree[a].second = 0;
return 0;
}
vector<int> ans, visited;
int main() {
int n, m;
cin >> n >> m;
int base = n - 1;
REP(i, n) {
vertexs.push_back(vector<pair<int, int>>());
}
set<int> listings;
REP(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
listings.insert(c);
unioning[c].push_back(make_pair(a, b));
}
REP(i, n) {
union_tree[i] = make_pair(i, 1);
}
for (auto tea = listings.begin(); tea != listings.end(); ++tea) {
int i = *tea;
set<int> as;
for (int q = 0; q < unioning[i].size(); ++q) {
int a = unioning[i][q].first;
int b = unioning[i][q].second;
union_merge(a, b);
as.insert(a);
as.insert(b);
}
map<int, int> gogo;
for (auto q = as.begin(); q != as.end(); ++q) {
int topping = union_find(*q);
if (gogo[topping] == 0) {
gogo[topping] = vertexs.size();
vertexs.push_back(vector<pair<int, int>>());
}
vertexs[*q].push_back(make_pair(gogo[topping], 1));
vertexs[gogo[topping]].push_back(make_pair(*q, 0));
}
for (auto q = as.begin(); q != as.end(); ++q) {
union_tree[*q] = make_pair(*q, 1);
}
}
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> next;
next.push(make_pair(0, 0));
ans.push_back(0);
visited.push_back(0);
for (int i = 1; i < vertexs.size(); ++i) {
ans.push_back(10000000);
visited.push_back(0);
}
while (next.empty() == false) {
int now = next.top().second;
next.pop();
if (visited[now] == true) continue;
visited[now] = true;
for (int i = 0; i < vertexs[now].size(); ++i) {
if (ans[vertexs[now][i].first] > ans[now] + vertexs[now][i].second) {
ans[vertexs[now][i].first] = ans[now] + vertexs[now][i].second;
next.push(make_pair(ans[vertexs[now][i].first], vertexs[now][i].first));
}
}
}
if (ans[base] == 10000000) {
cout << -1 << endl;
}
else {
cout << ans[base] << endl;
}
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#include <iomanip>
#define intt long long
int main() {
intt N, M; std::cin >> N >> M;
std::vector<intt> s(M);
std::vector<intt> c(M);
for (int i = 0; i < M; ++i) {
std::cin >> s[i] >> c[i];
if (s[i] == 1 && c[i] == 0 && N != 1) {
std::cout << -1 << std::endl;
return 0;
}
}
for (int i = 0; i < M; ++i) {
if (s[i] > N) {
std::cout << -1 << std::endl;
return 0;
}
for (int j = 0; j < M; ++j) {
if (s[i] == s[j] && c[i] != c[j]) {
std::cout << -1 << std::endl;
return 0;
}
}
}
intt ans = 0;
bool m1 = false;
bool m2 = false;
bool m3 = false;
int p1 = 0;
int p2 = 0;
int p3 = 0;
for (int i = 0; i < M; ++i) {
if (s[i] == 1) {
m3 = true;
p3 = i;
}
if (s[i] == 2) {
m2 = true;
p2 = i;
}
if (s[i] == 3){
m1 = true;
p1 = i;
}
}
if (N == 3) {
if (m3 == true)
ans += c[p3] * 100;
if (m2 == true)
ans += c[p2] * 10;
if (m1 == true)
ans += c[p1];
}
else if (N == 2) {
if (m3 == true)
ans += c[p3] * 10;
if (m2 == true)
ans += c[p2];
}
else if (N == 1) {
if (m3 == true)
ans += c[p3];
}
if (N == 3 && ans < 100)
ans += 100;
if (N == 2 && ans < 10)
ans += 10;
std::cout << ans << std::endl;
return 0;
} | 0 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int step(int s, vector<int> &dp, int n) {
int cnt = 0;
if (s == n) return 1;
for (int i = 1; i <= 3; i++) {
if (s + i <= n) {
if (dp[s + i] == -1)
cnt += step(s + i, dp, n);
else
cnt += dp[s + i];
}
}
dp[s] = cnt;
return cnt;
}
int main(void) {
int n;
vector<int> dp;
vector<int> res;
dp.resize(31, -1);
while (cin >> n, n) {
int cnt = 0;
for (int i = 1; i <= 3; i++)
cnt += step(i, dp, n);
dp.clear();
dp.resize(31, -1);
res.push_back(cnt / 10 / 365 + 1);
}
for (int i = 0; i < res.size(); i++)
cout << res[i] << endl;
} | #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define res(i,n) for(int i=n;;i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(long long x, long long y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(long long x, long long y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
int N; cin >> N;
for (long double i = N; i > 0; i--) {
if (sqrt(i) == int(sqrt(i))) {
cout << int(i) << endl;
return 0;
}
}
} | 0 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0;i < (n);i++)
using ll = long long;
const ll MOD=1000000007;
const double pi=acos(-1);
int main()
{
ll N,K; cin>>N>>K;
vector<ll> A(N);
rep(i,N)
{
cin>>A.at(i);
}
rep(i,min(K,(ll)100))
{
vector<ll> hoge(N,0);
vector<ll> sirusi(N,0);
rep(j,N)
{
sirusi.at(max((ll)0,j-A.at(j)))++;
if(j+A.at(j)<N-1)
{
sirusi.at(j+A.at(j)+1)--;
}
}
rep(j,N)
{
if(j==0) {hoge.at(0)=sirusi.at(0); continue;}
hoge.at(j)=hoge.at(j-1)+sirusi.at(j);
}
A=hoge;
}
rep(i,N)
{
if(i!=0) {cout<<" ";}
cout<<A.at(i);
}
cout<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef priority_queue<int> HEAP;
typedef priority_queue<int, vector<int>, greater<int> > RHEAP;
const int N = 510, M = 1010;
int a, b, n = 100;
char g[N][N];
int main()
{
cin >> a >> b;
a -- , b -- ;
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
g[i][j] = i <= 50 ? '#' : '.';
for (int i = 1; a && i <= n / 2 - 1; i += 2)
for (int j = 1; a && j <= n; j += 2, a -- )
g[i][j] = '.';
for (int i = n / 2 + 2; b && i <= n; i += 2)
for (int j = 1; b && j <= n; j += 2, b -- )
g[i][j] = '#';
puts("100 100");
for (int i = 1; i <= n; i ++ ) puts(g[i] + 1);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define endl '\n'
using ll=long long;
const int INF=1e9+5;
const ll lim=(ll)3e16;
const int N=510000;
const int mod=1e9+7;
const ll oo=1e18+5;
int main(){
ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(0);
int n;
cin>>n;
if(n<3) return cout<<-1,0;
if(n==3){
cout<<"aa.\n..a\n..a"<<endl;
return 0;
}
vector<string> matrixx[8];
// 4
matrixx[4].push_back("aabc");
matrixx[4].push_back("ddbc");
matrixx[4].push_back("bcaa");
matrixx[4].push_back("bcdd");
// 5
matrixx[5].push_back("aabba");
matrixx[5].push_back("bcc.a");
matrixx[5].push_back("b..cb ");
matrixx[5].push_back("a..cb");
matrixx[5].push_back("abbaa");
// 6
matrixx[6].push_back("aabc..");
matrixx[6].push_back("ddbc..");
matrixx[6].push_back("..aabc");
matrixx[6].push_back("..ddbc");
matrixx[6].push_back("bc..aa");
matrixx[6].push_back("bc..dd");
//7
matrixx[7].push_back("aabbcc.");
matrixx[7].push_back("dd.dd.a");
matrixx[7].push_back("..d..da");
matrixx[7].push_back("..d..db");
matrixx[7].push_back("dd.dd.b");
matrixx[7].push_back("..d..dc");
matrixx[7].push_back("..d..dc");
int rem=n%4;
int k=n/4;
if(rem) --k;
int times=-1;
//~ int loopp=0;
for(int i=0;i<k*4;++i)
{
if(i%4==0) ++times;
for(int j=0;j<times*4;++j) cout<<".";
cout<<matrixx[4][i%4];
for(int j=times*4+4;j<n;++j) cout<<".";
cout<<endl;
}
++times;
if(rem){
for(int i=0;i<4+rem;++i){
for(int j=0;j<times*4;++j) cout<<".";
cout<<matrixx[rem+4][i%(rem+4)];
cout<<endl;
}
}
return 0;
}
| // luogu-judger-enable-o2
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define db double
#define in inline
namespace fast_io
{
char buf[1<<12],*p1=buf,*p2=buf,sr[1<<23],z[23],nc;int C=-1,Z=0,Bi=0;
in char gc() {return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<12,stdin),p1==p2)?EOF:*p1++;}
in ll read()
{
ll x=0,y=1;while(nc=gc(),(nc<48||nc>57)&&nc!=-1)if(nc==45)y=-1;Bi=1;
x=nc-48;while(nc=gc(),47<nc&&nc<58)x=(x<<3)+(x<<1)+(nc^48),Bi++;return x*y;
}
in db gf() {int a=read(),b=(nc!='.')?0:read();return (b?a+(db)b/pow(10,Bi):a);}
in int gs(char *s) {char c,*t=s;while(c=gc(),c<32);*s++=c;while(c=gc(),c>32)*s++=c;return s-t;}
in void ot() {fwrite(sr,1,C+1,stdout);C=-1;}
in void flush() {if(C>1<<22) ot();}
template <typename T>
in void write(T x,char t)
{
int y=0;if(x<0)y=1,x=-x;while(z[++Z]=x%10+48,x/=10);
if(y)z[++Z]='-';while(sr[++C]=z[Z],--Z);sr[++C]=t;flush();
}
in void write(char *s) {int l=strlen(s);for(int i=0;i<l;i++)sr[++C]=*s++;sr[++C]='\n';flush();}
}
using namespace fast_io;
const int N=1e3+5;
int n;
char ans[1005][1005];
string s3[3]={
"aab",
"b.b",
"baa",
};
string s4[4]={
"bacc",
"babb",
"ccda",
"aada",
};
string s5[5]={
"accbb",
"ad..a",
"bd..a",
"b.ddc",
"aabbc",
};
string s6[6]={
"oorrzz",
".a.b.c",
".a.b.c",
"d.e.f.",
"d.e.f.",
"oorrzz"
};
string s7[7]={
"..bbcca",
"ccdd..a",
".a..d.b",
".a..d.b",
"b....dc",
"b....dc",
"ccbbaa.",
};
int main()
{
n=read();if(n<3) return puts("-1"),0;
for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) ans[i][j]=0;
if(n==3) {for(int i=1;i<=n;i++){for(int j=1;j<=n;j++) sr[++C]=s3[i-1][j-1];sr[++C]='\n';}return ot(),0;}
if(n==4) {for(int i=1;i<=n;i++){for(int j=1;j<=n;j++) sr[++C]=s4[i-1][j-1];sr[++C]='\n';}return ot(),0;}
if(n==5) {for(int i=1;i<=n;i++){for(int j=1;j<=n;j++) sr[++C]=s5[i-1][j-1];sr[++C]='\n';}return ot(),0;}
if(n==6) {for(int i=1;i<=n;i++){for(int j=1;j<=n;j++) sr[++C]=s6[i-1][j-1];sr[++C]='\n';}return ot(),0;}
if(n==7) {for(int i=1;i<=n;i++){for(int j=1;j<=n;j++) sr[++C]=s7[i-1][j-1];sr[++C]='\n';}return ot(),0;}
if(n%4==0) for(int i=1;i<=n;i+=4) for(int j=i;j<=i+3;j++) for(int k=i;k<=i+3;k++) ans[j][k]=s4[(j-1)%4][(k-1)%4];
if(n%4==1)
{
for(int i=1;i<=n-5;i+=4) for(int j=i;j<=i+3;j++) for(int k=i;k<=i+3;k++) ans[j][k]=s4[(j-1)%4][(k-1)%4];
for(int i=n-4;i<=n;i++) for(int j=n-4;j<=n;j++) ans[i][j]=s5[i-n+4][j-n+4];
}
if(n%4==2)
{
for(int i=1;i<=n-6;i+=4) for(int j=i;j<=i+3;j++) for(int k=i;k<=i+3;k++) ans[j][k]=s4[(j-1)%4][(k-1)%4];
for(int i=n-5;i<=n;i++) for(int j=n-5;j<=n;j++) ans[i][j]=s6[i-n+5][j-n+5];
}
if(n%4==3)
{
for(int i=1;i<=n-7;i+=4) for(int j=i;j<=i+3;j++) for(int k=i;k<=i+3;k++) ans[j][k]=s4[(j-1)%4][(k-1)%4];
for(int i=n-6;i<=n;i++) for(int j=n-6;j<=n;j++) ans[i][j]=s7[i-n+6][j-n+6];
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++) sr[++C]=(ans[i][j]?ans[i][j]:'.');
sr[++C]='\n';ot();
}
return 0;
}
//Author: disangan233
//In my dream's scene,I can see the everything that in Cyaegha.
/*
----------
aab
b.b
baa
----------
bacc
babb
ccda
aada
----------
accbb
ad..a
bd..a
b.ddc
aabbc
----------
aabb..
b..aa.
ba....
.a..aa
..a..b
..a..b
----------
..bbcca
ccdd..a
.a..d.b
.a..d.b
b....dc
b....dc
ccbbaa.
----------
*/ | 1 |
#include <iostream>
#include <vector>
#include <cmath>
template<typename T>
auto print(std::vector<T> array,bool reverse = false)
-> void{
if(reverse){
auto iterator = array.rbegin();
std::cout<<*iterator;
iterator++;
for(;iterator != array.rend();++iterator){
std::cout<<" "<< *iterator;
}
}else{
auto iterator = array.begin();
std::cout<<*iterator;
iterator++;
for(;iterator != array.end();++iterator){
std::cout<<" "<< *iterator;
}
}
std::cout<<"\n";
}
template<typename T>
auto println(std::vector<T> array)
-> void{
for(auto v : array){
std::cout<< v <<"\n";
}
}
int cnt = 0;
template<typename T>
auto insertionSort(std::vector<T> *A,int n,int g)
-> void{
for(int i = g;i < n;i++){
auto v = (*A)[i];
auto j = i - g;
while(j >= 0 && (*A)[j] > v){
(*A)[j+g] = (*A)[j];
j = j - g;
cnt++;
}
(*A)[j+g] = v;
}
}
template<typename T>
auto shellSort(std::vector<T> *A,int n)
-> void{
cnt = 0;
int h = 0;
std::vector<int> G;
for(int k = 1;;k++){
h = static_cast<int>((pow(3,k)-1)/2);
if(h > n)
break;
G.push_back(h);
}
std::cout<< G.size() <<std::endl;
print(G, true);
for(auto it = G.rbegin();it != G.rend();++it){
insertionSort<T>( A, n, (*it));
}
}
auto main()
-> int{
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
int n;
std::cin>>n;
std::vector<int> array(n);
for(int i=0;i < n;i++)
std::cin>>array[i];
shellSort( &array, n);
std::cout<< cnt <<"\n";
println(array);
return 0;
} | #include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;
#define MAX 256
int main(void){
int n;
scanf("%d", &n);
int i = 1, k = 0, x;
while (i <= n){
k = 0;
x = i;
if (i % 3 == 0)k = 1;
if (x % 10 == 3)k = 1;
while (x > 10){
x = x / 10;
if (x % 10 == 3)k = 1;
}
if (k == 1){
printf(" %d", i);
}
i++;
}
printf("\n");
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
#define rep(i,a) for(int i = 0 ; i < a ; i ++)
#define loop(i,a,b) for(int i = a ; i < b ; i ++)
typedef pair<int,int> pii;
#define MAX_V 110
#define INF (1<<30)
struct edge{int to,cost;};
vector<edge> G[MAX_V],IN[MAX_V];
int d[MAX_V];
void dijkstra(int s,int V){
priority_queue< pii,vector<pii>,greater<pii> > que;
rep(i,V)d[i]=INF;
d[s]=0;
que.push(pii(0,s));
while(que.size()){
pii p=que.top();
que.pop();
int v=p.second;
if(d[v]<p.first)continue;
rep(i,G[v].size()){
edge e=G[v][i];
if(d[e.to]>d[v]+e.cost){
d[e.to]=d[v]+e.cost;
que.push(pii(d[e.to],e.to));
}
}
}
}
int N,M,o;
int maze[100][100],tim[100][100];
int main(void){
while(cin>>N>>M,N+M){
rep(i,MAX_V)G[i].clear();
while(M--){
cin>>o;
if(o){
int a,b,c;
cin>>a>>b>>c;
--a,--b;
edge e = {b,c}, e1 = {a,c};
G[a].push_back(e);
G[b].push_back(e1);
}else{
int a,b;
cin>>a>>b;
--a,--b;
dijkstra(a,N);
cout<<(d[b]==(1<<30)?-1:d[b])<<endl;
}
}
}
} | #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
vector<pair<double, string>>x;
int n; double P, A, B, C, D, E, F, S, M; string L;
int main() {
while (true) {
x.clear();
cin >> n;
if (n == 0) { break; }
for (int i = 0; i < n; i++) {
cin >> L >> P >> A >> B >> C >> D >> E >> F >> S >> M;
x.push_back(make_pair(100000000.00 - ((F*S*M - P) / (A + B + C + (D + E)*M)), L));
}
sort(x.begin(), x.end());
for (int i = 0; i < n; i++) { cout << x[i].second << endl; }
cout << "#" << endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int H, W;
int seen[10000][10000];
char S[10000][10000];
vector<pair<ll, ll>> prime_factorize(ll n) { //素因数分解と各素数の個数
vector<pair<ll, ll>> res;
for (ll i = 2; i * i <= n; i++)
{
if (n % i != 0)
{
continue;
}
int num = 0;
while (n % i == 0)
{
++num;
n /= i;
}
res.push_back(make_pair(i, num));
}
if (n != 1)
{
res.push_back(make_pair(n, 1));
}
return res;
}
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
ll lcm(ll x, ll y) {
return x / GCD(x, y) * y;//先に割り算をして掛けられる数を小さくして掛け算を行う
}
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
void dfs(int st, int fi) {
// cout << st << " " << fi << endl;
if (st < 0 || fi < 0 || st >= H || fi >= W)
{
return ;
}
if (S[st][fi] == '#')
{
return ;
}
if (seen[st][fi] == 1)
{
return ;
}
if (S[st][fi] == '.')
{
seen[st][fi] = 1;
}
dfs(st + 1, fi);
dfs(st, fi + 1);
dfs(st, fi - 1);
dfs(st - 1, fi);
}
int main() {
int N;
cin >> N;
vector<int> p(N + 1);
p[1] = 0;
for(int i = 2; i <= N; i++) {
int n = i;
vector<pair<int, int>> b;
for(int j = 2; j * j <= n; j++) {
if(n % j != 0) continue;
int ex = 0;
while(n % j == 0) {
ex++;
n /= j;
}
b.push_back({j, ex});
}
if(n != 1) b.push_back({n, 1});
for(auto v : b) {
p[v.first] += v.second;
}
}
/*for(int i = 1; i <= N; i++)
cout << p[i] << endl;*/
ll ans = 1;
for(int i = 2; i <= N; i++) {
ans *= (p[i] + 1);
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define F(i, x, y) for (int i = (x); i <= (y); ++i)
#define Fr(i, x, y) for (int i = (x); i < (y); ++i)
using namespace std;
typedef long long ll;
const int N = 300000 + 5;
int n, A[N], cnt[N], B[N], Fl[N], Fr[N];
int tg[N];
void ad(int x, int t) {
if (x < 0 || x >= n) return ;
tg[x] += t;
}
void add(int l, int r) {
if (l>r) return ;
// cerr << "add: " << l << " " << r << '\n';
ad(l, 1); ad(r+1, -1);
}
int main() {
memset (Fl, -1, sizeof(Fl));
memset (Fr, -1, sizeof(Fr));
scanf ("%d", &n);
Fr(i, 0, n) scanf ("%d", &A[i]), ++cnt[A[i]], Fr[A[i]] = i;
for (int i = n-1; i >= 0; --i) Fl[A[i]] = i;
Fr(i, 0, n) scanf ("%d", &B[i]), ++cnt[B[i]];
if (*max_element(cnt, cnt + 300000) > n) return puts("No"), 0;
Fr(i, 0, n) {
// intersect: Fr = i initially Fr = Fr, i = 1
// Fl = j, initially Fl = Fl, i = 1
if (Fl[B[i]] == -1) continue;
int stl = (i - Fr[B[i]] + n) % n, str = (i - Fl[B[i]] + n) % n;
if (stl > str) add(stl, n-1), add(0, str);
else add(stl, str);
}
for (int i = 0; i < n; ++i) {
if (i) tg[i] += tg[i - 1];
if (!tg[i]){
puts("Yes");
int cur = i;
for (int j = 1; j <= n; ++j) {
printf("%d ", B[cur]);
(cur += 1) %= n;
}
return 0;
}
}
puts("No");
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(false);
int A, B, M;
cin >> A >> B >> M;
vector<int> a(A);
REP(i, A) cin >> a[i];
vector<int> b(B);
REP(i, B) cin >> b[i];
vector<int> x(M), y(M), c(M);
REP(i, M) cin >> x[i] >> y[i] >> c[i];
REP(i, M) {
x[i]--;
y[i]--;
}
int minA = *min_element(a.begin(), a.end());
int minB = *min_element(b.begin(), b.end());
int ans = minA + minB;
REP(i, M) {
ans = min(ans, a[x[i]] + b[y[i]] - c[i]);
}
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int s[5];
char op[5];
void solve(int index, int cur_sum) {
if (index == 3) {
if (cur_sum == 7) {
for(int i = 0; i < 4; ++i) {
if (i > 0) cout << op[i];
cout << s[i];
}
cout << "=7";
exit(0);
}
return;
}
// +
op[index + 1] = '+';
solve(index + 1, cur_sum+s[index + 1]);
//-
op[index + 1] = '-';
solve(index + 1, cur_sum-s[index + 1]);
}
int main () {
for(int i = 0; i < 4; ++i) {
char ch; cin >> ch;
s[i] = ch - '0';
}
solve(0, s[0]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for(ll (i)=(m);(i)<(n);++(i))
#define REP(i, n) FOR(i,n,0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll) 1e15;
ll A[1005];
ll B[1005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
REP(i, N) {
cin >> A[i];
}
REP(i, M) {
cin >> B[i];
}
sort(A, A + N, greater<ll>());
sort(B, B + M, greater<ll>());
ll ai = 0, bi = 0;
ll ans = 1;
REP(i, N - 1) {
if (A[i] == A[i + 1])
ans = 0;
}
REP(i, M - 1) {
if (B[i] == B[i + 1])
ans = 0;
}
if (A[0] != N * M || B[0] != N * M)
ans = 0;
for (ll i = N * M; i > 0; --i) {
if (A[ai + 1] == i)
ai++;
if (B[bi + 1] == i)
bi++;
ll n = ai + 1;
ll m = bi + 1;
if (A[ai] == i)
n = 1;
if (B[bi] == i)
m = 1;
ll p = n * m;
if (A[ai] != i && B[bi] != i)
p -= N * M - i;
ans = (ans * p) % MOD;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Pld = pair<ld, ld>;
using Vec = vector<ll>;
using VecP = vector<P>;
using VecB = vector<bool>;
using VecC = vector<char>;
using VecD = vector<ld>;
using VecS = vector<string>;
using Graph = vector<VecP>;
#define REP(i, m, n) for(ll (i) = (m); (i) < (n); ++(i))
#define REPR(i, m, n) for(ll (i) = (m); (i) > (n); --(i))
#define rep(i, n) REP(i, 0, n)
#define R cin>>
#define repr(i, n) REPR(i, n, 0)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define in(a) insert(a)
#define P(p) cout<<(p)<<endl;
#define ALL(x) (x).begin(),(x).end()
#define ALLR(x) (x).rbegin(),(x).rend()
#define SORT(a) sort((a).begin(), (a).end())
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long long int> vll;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;
void sonic(){ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);}
void setp(const ll n){cout << fixed << setprecision(n);}
const ll INF = 1e9+1;
const ll LINF = 1e18+1;
const ll mod = 1e9+7;
//const ll MOD = 998244353;
const ld PI = acos(-1);
const ld EPS = 1e-11;
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmin(T &a,const T &b){if(a>b){a=b;return true;}return false;}
template<typename T> void co(T e){cout << e << "\n";}
template<typename T> void co(const vector<T>& v){for(const auto& e : v)
{ cout << e << " "; } cout << "\n";}
ll gcd(ll a, ll b) {
if (a < b)swap(a, b);
if (b == 0) return a;
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a * b / g;
}
bool prime(ll n) {
for (ll i = 2; i <= sqrt(n); i++) {
if (n%i == 0)return false;
}
return n != 1;
}
int pow(int x, int y, int mod){
int ret=1;
for(;y;y>>=1,x=1ll*x*x%mod){
if(y&1) ret=1ll*ret*x%mod;
}
return ret;
}
int n = 3010, maxn = 3000;
ll fac[3010], inv[3010];
void init(){
fac[0]=1;
REP(i, 1, maxn+1)fac[i]=1ll*fac[i-1]*i%mod;
inv[maxn]=pow(fac[maxn], mod-2, mod);
REPR(j,maxn-1,-1)inv[j]=1ll*inv[j+1]*(j+1)%mod;
}
int main() {
sonic();
map<char, string> mp;
R mp['a'] >> mp['b'] >> mp['c'];
char pre = 'a', nxt;
while(mp[pre]!=""){
nxt=mp[pre][0];
mp[pre]=mp[pre].substr(1, mp[pre].length());
pre=nxt;
}
pre-=32;
co(pre);
}
| 0 |
#include<iostream>
#include<algorithm>
#include<cmath>
#include<stdio.h>
#include<cstdio>
using namespace std;
int main()
{
double x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
double X = max(x1, x2) - min(x1, x2);
double Y = max(y1, y2) - min(y1, y2);
printf("%.8lf\n", sqrt(X*X + Y*Y));
return 0;
} | #include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main() {
double x1, y1, x2, y2;
cin >> setprecision(10) >> x1;
cin >> setprecision(10) >> y1;
cin >> setprecision(10) >> x2;
cin >> setprecision(10) >> y2;
cout << setprecision(10) << sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); i++)
#define ll long long
using namespace std;
int main() {
ll n,m; cin >> n >> m;
if(n % m == 0){
cout << "0";
}
else{
cout << "1";
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
int S = A + B;
int T = A - B;
int U = A * B;
if (S >= T && S >= U) {
cout << S << endl;
} else if (T >= S && T >= U) {
cout << T << endl;
} else {
cout << U << endl;
}
} | 0 |
#include<stdio.h>
int main()
{
int n;
scanf("%d",&n);
n=n/3;
printf("%d\n",n);
} | #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#define maxn 510
#define ll long long
using namespace std;
int n;
ll a[maxn][maxn], primes[2020];
bool st[1000010];
int cnt;
void getprimes()
{
for (int i = 2; i <= 10000; i ++ )
{
if (!st[i]) primes[++cnt] = i;
for (int j = 1; primes[j] * i <= 10000; j ++ )
{
st[primes[j] * i] = 1;
if (i % primes[j] == 0) break;
}
}
}
ll gcd(ll a, ll b)
{
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b)
{
if (!a || !b) return a + b;
return a / gcd(a, b) * b;
}
int main()
{
getprimes();
scanf("%d", &n);
if (n == 2)
{
puts("2 3");
puts("5 4");
return 0;
}
for (int i = 1; i <= n; i ++ )
for (int j = (i + 1 & 1) + 1; j <= n; j += 2)
a[i][j] = primes[(i + j) / 2] * primes[n + (i - j) / 2 + (n + 1) / 2];
for (int i = 1; i <= n; i ++ )
for (int j = ((i & 1) + 1); j <= n; j += 2)
a[i][j] = lcm(lcm(a[i][j - 1], a[i - 1][j]), lcm(a[i + 1][j], a[i][j + 1])) + 1;
for (int i = 1; i <= n; i ++ )
{
for (int j = 1; j <= n; j ++ ) cout << a[i][j] << ' ';
puts("");
}
return 0;
} | 0 |
/*https://atcoder.jp/contests/abc084/tasks/abc084_b*/
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
int a, b;
string s;
cin >> a >> b >> s;
if (s.size() != a + b + 1 || s[a] != '-')
{
cout << "No";
return 0;
}
for (int i = 0; i < s.size(); i++)
{
if (i != a)
{
if (s[i] < 48 || s[i] > 57)
{
cout << "No";
return 0;
}
}
}
cout << "Yes";
} | #include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int main()
{
int p,q,r,sum,maxm;
cin >> p >> q >> r;
sum = p + q + r;
maxm = max({p,q,r});
cout << sum - maxm;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define N 4444
#define mod 998244353
int n,k,C[N][N],pw2[N];
int c(int n,int m){
if (m>n||m<0)
return 0;
return C[n][m];
}
int calc(int m,int n){return c(n+m-1,m-1);}
int Get(int v,int n,int k){
int ans=0;
int lim=max(0,v/2-max(0,v-1-k));
for (int i=0;i<=lim;i++)
ans=(1LL*pw2[i]*C[lim][i]%mod*calc(k-lim*2+i,n-i)+ans)%mod;
return ans;
}
int main(){
pw2[0]=1;
for (int i=1;i<N;i++)
pw2[i]=pw2[i-1]*2%mod;
for (int i=0;i<N;i++)
C[i][0]=C[i][i]=1;
for (int i=1;i<N;i++)
for (int j=1;j<i;j++)
C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
scanf("%d%d",&k,&n);
for (int i=2;i<=2*k;i++)
if (i&1)
printf("%d\n",Get(i,n,k));
else
printf("%d\n",(Get(i-1,n,k-1)+Get(i-1,n-1,k-1))%mod);
return 0;
} | #include <iostream>
#include <vector>
#include <bitset>
using namespace std;
long long const mod = 1000000007;
int n, x[3], v;
vector< vector<long long> > dp;
bool g(int mem, int a){
int m = mem, sum = 0, prc = 2;
if(a == x[2]) prc--;
else sum = a;
while(m > 0){
int tmp = 1;
while(m%2 == 0){
m >>= 1;
tmp++;
}
sum += tmp;
if(sum == x[prc]){
sum = 0;
if(prc-- == 0) return false;
}else if(sum > x[prc]) return true;
m >>= 1;
}
return true;
}
long long f(int id, int mem){
if(id == n) return 1;
if(dp[id][mem] != -1) return dp[id][mem];
long long res = 0;
for(int a = 1; a <= 10; a++){
if(g(mem, a)) res += f(id+1, ((mem<<a)+(1<<(a-1)))%v);
}
return dp[id][mem] = res % mod;
}
int main(void){
cin >> n >> x[0] >> x[1] >> x[2];
v = (1<<(x[0]+x[1]+x[2]-1));
dp.assign(n, vector<long long>(v, -1));
long long ans = 1;
for(int i=0;i<n;i++) ans = ans * 10 % mod;
ans += mod - f(0, 0);
cout << ans%mod << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define TEMP_T template<typename T>
TEMP_T void sort(T& v){ sort(v.begin(), v.end()); }
TEMP_T void revs(T& v){ reverse(v.begin(), v.end()); }
TEMP_T void uniq(T& v){ sort(v); v.erase(unique(v.begin(), v.end()), v.end()); }
TEMP_T T cums(T& v){ T r(v.size()); partial_sum(v.begin(), v.end(), r.begin()); return r; }
TEMP_T void show(T& v, char delim=' ', char end='\n'){ for(int i=0; i<v.size()-1; i++) cout << v[i] << delim; cout << v[v.size()-1] << end; }
TEMP_T T acum(vector<T>& v, T b=0){ return accumulate(v.begin(), v.end(), b); }
TEMP_T vector<T> inpt(int n){ vector<T> v(n); for (int i=0; i<n; i++) cin >> v[i]; return v; }
static inline int in(){ int x; scanf("%d", &x); return x; }
int main()
{
int n, p;
while (n = in(), p = in(), n || p){
int id = 0;
int stone[64] = {};
int cnt = p;
int have_user = 0;
while (1){
if (cnt == 1 &&
((stone[id] && have_user == 1) ||
(!stone[id] && have_user == 0))){
break;
}
if (cnt == 0){
if (stone[id]) have_user--;
cnt = stone[id];
stone[id] = 0;
}
else {
if (stone[id] == 0) have_user++;
cnt--;
stone[id]++;
}
id = (id + 1) % n;
}
printf("%d\n", id);
}
return (0);
} | #include<iostream>
#include<vector>
using namespace std;
int main() {
int n, p;
while (cin >> n >> p, n) {
int now = 0,wan=p;
vector<int>person(n,0);
while (true) {
if (wan) {
person[now]++; wan--;
if (person[now] == p) {
cout << now << endl;
break;
}
}
else if (person[now]) {
wan = person[now]; person[now] = 0;
}
now++;
if (now >= n)now = 0;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N=110;
int h,w,px,py,f[N][N][N][N],col[N][N],row[N][N];
bool mp[N][N];
void Init()
{
scanf("%d%d",&h,&w);
for (int i=1;i<=h;++i)
for (int j=1;j<=w;++j)
{
char ch=getchar();
while (ch!='o' && ch!='.' && ch!='E') ch=getchar();
if (ch=='E') px=i,py=j;
if (ch=='o') mp[i][j]=1;
else mp[i][j]=0;
}
}
int Col(int r,int l,int x)
{
if (l>r) return 0;
return col[r][x]-col[l][x];
}
int Row(int r,int l,int x)
{
if (l>r) return 0;
return row[x][r]-row[x][l];
}
void Solve()
{
for (int i=1;i<=h;++i)
for (int j=1;j<=w;++j)
{
col[i][j]=col[i-1][j]+mp[i][j];
row[i][j]=row[i][j-1]+mp[i][j];
}
int ans=0;
for (int a=px;a>0;--a)
for (int b=px;b<=h;++b)
for (int c=py;c>0;--c)
for (int d=py;d<=w;++d) f[a][b][c][d]=-1e9;
f[px][px][py][py]=0;
for (int a=px;a>0;--a)
for (int b=px;b<=h;++b)
for (int c=py;c>0;--c)
for (int d=py;d<=w;++d)
{
if (a>1 && a-1>b-px)
f[a-1][b][c][d]=max(f[a-1][b][c][d],f[a][b][c][d]+Row(min(w-(py-c),d),max(c-1,d-py),a-1));
if (b<h && h-b>px-a)
f[a][b+1][c][d]=max(f[a][b+1][c][d],f[a][b][c][d]+Row(min(w-(py-c),d),max(c-1,d-py),b+1));
if (c>1 && c-1>d-py)
f[a][b][c-1][d]=max(f[a][b][c-1][d],f[a][b][c][d]+Col(min(h-(px-a),b),max(a-1,b-px),c-1));
if (d<w && w-d>py-c)
f[a][b][c][d+1]=max(f[a][b][c][d+1],f[a][b][c][d]+Col(min(h-(px-a),b),max(a-1,b-px),d+1));
ans=max(ans,f[a][b][c][d]);
}
printf("%d\n",ans);
}
int main()
{
Init();
Solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pp;
typedef pair<ll,ll> pll;
void read(int& x){ scanf("%d",&x); }
void read(ll& x){ scanf("%lld",&x); }
template<typename T,typename... Args>
void read(T& a,Args&... b){ read(a); read(b...); }
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define eb emplace_back
#define x first
#define y second
int n, m;
int x, y;
int a[110][110];
char buf[110];
void in(){
read(n, m);
for(int i=1; i<=n; ++i){
scanf("%s", buf+1);
for(int j=1; j<=m; ++j){
a[i][j]=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
if(buf[j] == 'o'){
++a[i][j];
} else if(buf[j] == 'E'){
x=i; y=j;
}
}
}
}
int dp[102][102][102][102];
int rect(int L1, int R1, int D1, int U1, int L2, int R2, int D2, int U2){
int L=max(L1, L2);
int R=min(R1, R2);
int D=max(D1, D2);
int U=min(U1, U2);
if(L>R || D>U) return 0;
if(0) printf("%d %d %d %d\n", L, R, D, U);
return a[R][U]-a[L-1][U]-a[R][D-1]+a[L-1][D-1];
}
int main()
{
in();
for(int w=1; w<=n; ++w){
for(int h=1; h<=m; ++h){
for(int l=1; l+w-1<=n; ++l){
int r=l+w-1;
if(x<l || r<x) continue;
for(int d=1; d+h-1<=m; ++d){
int u=d+h-1;
if(y<d || u<y) continue;
int me=dp[l][r][d][u];
auto f = [&](int A, int B, int C, int D){
int I=l+A;
int J=r+B;
int K=d+C;
int L=u+D;
int nv = rect(1+(r-x), n-(x-l), 1+(u-y), m-(y-d),
(A||B)?(A?I:J):(I),
(A||B)?(A?I:J):(J),
(C||D)?(C?K:L):(K),
(C||D)?(C?K:L):(L)
);
int& T=dp[I][J][K][L];
if(T < me+nv){
if(0) printf("upd from %d-%d, %d-%d to df %d %d %d %d : %d+%d = %d\n",
l,r,d,u, A,B,C,D, me, nv, me+nv);
}
T=max(T, me+nv);
};
if(1 < l) f(-1, 0, 0, 0);
if(r < n) f(0, 1, 0, 0);
if(1 < d) f(0, 0, -1, 0);
if(u < m) f(0, 0, 0, 1);
}
}
}
}
printf("%d\n", dp[1][n][1][m]);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
vector<int64_t>A(N);
for(int i=0;i<N;i++)
cin>>A.at(i);
vector<int64_t>B(1+N);
map<int64_t,int64_t>M;
M[1]=A.at(0);
for(int i=2;i<=N;i++)
if(i%2==1)
M[i]=M.at(i-2)+A.at(i-1);
B.at(0)=0;
B.at(0)=0;
B.at(2)=max(A.at(0),A.at(1));
for(int i=3;i<=N;i++){
if(i%2==0)
B.at(i)=max(A.at(i-1)+B.at(i-2),A.at(i-2)+M.at(i-3));
else
B.at(i)=max(A.at(i-1)+B.at(i-2),A.at(i-2)+B.at(i-3));
}cout<<B.at(N)<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios:: sync_with_stdio(false);
cin.tie();
int x;
cin >> x;
int mi = x;
int mx = x;
for (int i = 0; i < 4; i++) {
cin >> x;
mi = min(mi, x);
mx = max(mx, x);
}
int k;
cin >> k;
cout << ((mx - mi) <= k ? "Yay!" : ":(");
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string str;
cin>>str;
if(str.size()==2){
cout<<str<<endl;
}
else{
cout<<str.at(2)<<str.at(1)<<str.at(0)<<endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(),(x).end()
#define endl "\n"
using ll = long long;
using P = pair<int,int>;
using mp = map<string,int>;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
string s;
cin >> s;
if(s.size() == 3) {
reverse(all(s));
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
#define Rep(i,n) for(int i=1;i<=n;i++)
const ll MOD = 1000000007;
long long modinv(long long a, long long m=MOD) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
/*MODの割り算の際に
a/＝b;
を
a *= modinv(b,MOD);
とする。
*/
}
int main(){
int R;cin >> R;
double ans = R * 2 * M_PI;
printf("%0.5f\n", ans);
return 0;
} | #include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<string>
#include<functional>
#include<queue>
#include<stack>
#include<math.h>
#define INF 1000000001
#define EPS 1.0e-6
using namespace std;
typedef long long ll;
int main()
{
int n;
while (cin >> n) {
int s = 0;
for (int i = 1; i < 600 / n; i++) {
s += (i*n)*(i*n)*n;
}
cout << s << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define int long long
typedef long long ll;
using namespace std;
const ll MAXN = 200000;
const ll INF = 1001001001;
const ll MOD = 1000000007;
ll N, ans=1, tmp=0;
vector<char> A;
vector<ll> B;
signed main(){
cin >> N;
for(int i=0;i<2*N;i++) {
char a;
cin >> a;
A.push_back(a);
}
ll ct=0;
for(int i=0;i<A.size()-1;i++) {
if(A[i]==A[i+1]) {
ct++;
//cout << ct << endl;
}
if(ct%2==1) {
tmp = i+1-2*B.size();
B.push_back(tmp);
if(tmp<=0) {
cout << 0 << endl;
return 0;
}
}
}
if(A[0]=='W'||ct%2==0||B.back()!=1) {
cout << 0 << endl;
return 0;
}
for(int i=0;i<B.size();i++) {
ans *= B[i];
ans %= MOD;
//cout << B[i] << endl;
}
//cout << ans << endl;
for(int i=1;i<=N;i++) {
ans *= i;
ans %= MOD;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define IOS ios_base::sync_with_stdio(0); cin.tie(); cout.tie();
#define ff first
#define ss second
#define pb push_back
#define debug(val) cerr << "The Value Of " << #val << " is : " << val << '\n';
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
const ll mod = 1e9 + 7;
const ll inf = 0x3f3f3f3f;
const ll mininf = -922337203685477;
const ll nax = 1e5+5;
ll n, arr[nax];
unordered_map<ll, bool>vis;
unordered_map<ll, ll>cnt;
vector<ll>v;
int main(){
IOS
cin >> n;
for(int i=0;i<n;i++){
cin >> arr[i];
cnt[arr[i]]++;
if(!vis[arr[i]]){
vis[arr[i]]=1;
v.pb(arr[i]);
}
}
sort(v.rbegin(), v.rend());
bool udah=0;
ll satu;
for(auto x:v){
if(cnt[x]>=4 && !udah){
cout << x * x << '\n';
return 0;
}
if(cnt[x]>=2){
if(udah){
cout << satu * x << '\n';
return 0;
}
else{
udah=1;
satu=x;
}
}
}
cout << 0 << '\n';
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long ll;
typedef pair<ll,ll> P;
const ll mod=1000000007;
const ll LINF=1LL<<60;
const int INF=1<<30;
vector<vector<bool>> used(500,vector<bool>(500,false));
P bfs(int N,int M,vector<string> field,int sx,int sy){
int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1};
queue<P> que;
que.push(P(sx,sy));
used[sx][sy] = true;
P ans = mp(0,0);
if (field[sx][sy] == '.'){
ans.fs++;
}
else{
ans.sc++;
}
//キューが空になるまでループ
while(que.size()){
P p = que.front();
que.pop();//先頭を取り出す
for (int i = 0;i < 4;i++){
int nx = p.fs + dx[i], ny = p.sc + dy[i];
//nx,nyが進めるマスか、行ったことのないマスかどうかを判定
if (field[p.fs][p.sc] == '.'){
if (0 <= nx && nx < N && 0 <= ny && ny < M && field[nx][ny] != '.' && !used[nx][ny]){
que.push(P(nx,ny));//追加
used[nx][ny] = true;
ans.sc++;
}
}
else{
if (0 <= nx && nx < N && 0 <= ny && ny < M && field[nx][ny] != '#' && !used[nx][ny]){
que.push(P(nx,ny));//追加
used[nx][ny] = true;
ans.fs++;
}
}
}
}
return ans;
}
int main(){
int h,w;cin>>h>>w;
vector<string> s(h);
for(int i = 0; i < h; i++) {
cin>>s[i];
}
ll ans = 0;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
if (!used[i][j]){
P res = bfs(h,w,s,i,j);
ans += (res.fs * res.sc);
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i,o,n) for(long long i = o;i<n;i++)
#define oneforall ios::sync_with_stdio(false);cin.tie(0);
#define all(v) (v).begin(),(v).end()
#define ini(...) int __VA_ARGS__; in(__VA_ARGS__)
#define inl(...) long long __VA_ARGS__; in(__VA_ARGS__)
#define ins(...) string __VA_ARGS__; in(__VA_ARGS__)
#define int long long
const long long INF=1e18;
void in(){} template <typename T,class... U> void in(T &t,U &...u){ cin >> t; in(u...);}
void out(){cout << "\n";} template <typename T,class... U> void out(const T &t,const U &...u){ cout << t; if(sizeof...(u)) cout << " "; out(u...);}
typedef vector<int> vi;
typedef vector<long long> vl;
typedef long long ll;
typedef vector<pair<long, long > > vpll;
typedef vector<pair<int, int > > vpii;
ll mo=1000000007;
ll comb(ll N_, ll C_) {
const int NUM_=310000;
static ll fact[NUM_+1],factr[NUM_+1],inv[NUM_+1];
if (fact[0]==0) {
inv[1]=fact[0]=factr[0]=1;
for (int i=2;i<=NUM_;++i) inv[i] = inv[mo % i] * (mo - mo / i) % mo;
for (int i=1;i<=NUM_;++i) fact[i]=fact[i-1]*i%mo, factr[i]=factr[i-1]*inv[i]%mo;
}
if(C_<0 || C_>N_) return 0;
return factr[C_]*fact[N_]%mo*factr[N_-C_]%mo;
}
int32_t main() {
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
oneforall
ini(n);
ins(morty);
ini(n1);
FOR(i,0,n1){
ini(x);
int d = 0;
int m = 0;
int dm = 0;
int tmp = 0;
int i1 = 0;
FOR(i,0,n){
if(morty[i] == 'D')d++;
else if(morty[i] == 'M'){
m++;
dm+=d;
}
else if(morty[i] == 'C'){
tmp+=dm;
}
if(i>=x-1){
if(morty[i1] == 'D'){
dm-=m;
d--;
}
else if(morty[i1] == 'M')m--;
i1++;
}
}
out(tmp);
}
return 0;
}
| 0 |
#include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using LP = pair<ll, ll>;
const double PI = 3.1415926535897932;
int main()
{
int N, K;
cin >> N >> K;
vector<double> P(N);
rep(i, N) {
cin >> P[i];
P[i] = (P[i] + 1) / 2.0;
}
vector<double> Sm(N, 0);
for (int i = 0; i < K; ++i) {
Sm[0] += P[i];
}
double max_sum = Sm[0];
int idx = 0;
for (int i = 1; i <= (N - K); ++i) {
Sm[i] = Sm[i - 1] - P[i - 1] + P[i + K - 1];
if (Sm[i] > max_sum) {
idx = i;
max_sum = Sm[i];
}
}
cout << fixed << setprecision(10) << max_sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
template<class T> inline bool chmin(T& a, T b){
if(a > b){
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b){
if(a < b){
a = b;
return true;
}
return false;
}
int main(){
int n;
ll T;
cin >> n >> T;
ll ans = 0;
vector<ll> v(n);
for(int i = 0; i < n; i++){
cin >> v[i];
}
for(int i = 1; i < n; i++){
ans += min(T, v[i] - v[i-1]);
}
ans += T;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define modo 1000000007
#define mod 998244353
#define pi acos(-1.0)
const ll INF = 1LL<<61;
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; }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;} //jou(n,mod-2)で逆元
//intの最大値2147483647 ≒ 2×10^9
//long longの最大値9223372036854775807 ≒ 9×10^18
//'大文字'+=32; で小文字に
// cout << fixed << setprecision (20); 小数点以下2０桁まで
//実行時間制約2秒では２×10^8回くらいまで計算できる
int main(){
int n;
cin>>n;
int x;
cin>>x;
if(x!=0){
cout << 0 << endl;
return 0;
}
vector<ll> p(n);
rep(i,n-1){
int y;
cin>>y;
if(y==0){
cout << 0 << endl;
return 0;
}
p[y]++;
}
repo(i,n-1){
if(p[i]==0&&p[i+1]!=0){
cout << 0 << endl;
return 0;
}
}
ll ans=1;
for(int i=1;i<n-1;i++){
ans*=jou(p[i],p[i+1]);
ans%=998244353ll;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
using ull=unsigned long long;
#define mod 1000000007
#define mod2 998244353
#define PI 3.14159265
#define ll long long
#define ld long double
#define pi pair<ll,ll>
#define pb push_back
#define vi vector<ll>
#define sz size()
#define setbits(x) __builtin_popcount(x)
#define fi first
#define se second
#define lz length()
#define all(x) (x).begin(),(x).end()
#define scf(x) scanf("%lld",&x)
#define rep(i,n) for(ll i=0;i<n;i++)
const int INF = (int)1e9;
const ll IINF=1LL<<62;
const int maxn=10000005;
//int divr[maxn];
/**/
/*void divisor()
{for(int i=2;i<sqrt(maxn);i++)
{
if(!divr[i])
{
for(int j=i*i;j<maxn;j+=i)if(!divr[j])divr[j]=i;
}
}
for(int i=1;i<maxn;i++)if(!divr[i])divr[i]=i;
}*/
/*const int N=1000005;
ll n;
struct line {
long long m, c;
long long eval(long long x) { return m * x + c; }
long double intersectX(line l) { return (long double) (c - l.c) / (l.m - m); }
};
vector<pair<pi,ll>> rect;
deque<line> dq;
*/
ll modexpo(ll a,ll b)
{
ll res=1LL;
while(b>0)
{
if(b&1)res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res;
}
int dp[200][200];
int x[100][100],y[100][100];
int main()
{
int n;
cin>>n;
int a[n];
int mx=0;
for(int i=0;i<n;i++){cin>>a[i];
mx=max(mx,a[i]);}
if(a[0]!=0){cout<<0;return 0;}
int ct[100005]={0};
for(int i=0;i<n;i++){
ct[a[i]]++;
}
if(ct[0]!=1){cout<<0;return 0;}
ll res=1LL;
for(int i=0;i<mx;i++){
for(int j=0;j<ct[i+1];j++){
res=(res*(ct[i]%mod2))%mod2;
res%=mod2;
}
}
cout<<res;
}
| 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ld pie=3.1415926535;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
int n,cnt=0; cin>>n;
string s; cin>>s;
vector<string> c={"SS","SW","WS","WW"};
for(auto st:c){
string ans=s;
ans[0]=st[0]; ans[1]=st[1];
for(int i=2;i<n;i++){
if(ans[i-2]=='S' && ans[i-1]=='S' && s[i-1]=='o')
ans[i]='S';
if(ans[i-2]=='S' && ans[i-1]=='S' && s[i-1]=='x')
ans[i]='W';
if(ans[i-2]=='S' && ans[i-1]=='W' && s[i-1]=='o')
ans[i]='W';
if(ans[i-2]=='S' && ans[i-1]=='W' && s[i-1]=='x')
ans[i]='S';
if(ans[i-2]=='W' && ans[i-1]=='S' && s[i-1]=='o')
ans[i]='W';
if(ans[i-2]=='W' && ans[i-1]=='S' && s[i-1]=='x')
ans[i]='S';
if(ans[i-2]=='W' && ans[i-1]=='W' && s[i-1]=='o')
ans[i]='S';
if(ans[i-2]=='W' && ans[i-1]=='W' && s[i-1]=='x')
ans[i]='W';
}
if(ans[n-1]=='S'){
if((ans[n-2]==ans[0] && s[n-1]=='o') ||
(ans[n-2]!=ans[0] && s[n-1]=='x')){
if(ans[0]=='S'){
if((ans[n-1]==ans[1] && s[0]=='o') ||
(ans[n-1]!=ans[1] && s[0]=='x')){
cout<<ans<<endl;
break;
}
}
else{
if((ans[n-1]==ans[1] && s[0]=='x') ||
(ans[n-1]!=ans[1] && s[0]=='o')){
cout<<ans<<endl;
break;
}
}
}
}
else{
if((ans[n-2]==ans[0] && s[n-1]=='x') ||
(ans[n-2]!=ans[0] && s[n-1]=='o')){
if(ans[0]=='S'){
if((ans[n-1]==ans[1] && s[0]=='o') ||
(ans[n-1]!=ans[1] && s[0]=='x')){
cout<<ans<<endl;
break;
}
}
else{
if((ans[n-1]==ans[1] && s[0]=='x') ||
(ans[n-1]!=ans[1] && s[0]=='o')){
cout<<ans<<endl;
break;
}
}
}
}
cnt++;
if(cnt==4) cout<<-1<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool can = true;
if(S.at(0)!='A') can = false;
int num_C = 0;
for(int i=2;i<S.size()-1;i++){
if(S.at(i)=='C') num_C ++;
}
if(num_C!=1) can =false;
int num_upper = 0;
for(int i=0;i<S.size();i++){
if(isupper(S.at(i))) num_upper ++;
}
if(num_upper!=2) can = false;
if(can) cout << "AC" << endl;
else cout << "WA" << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
// macro
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
// code starts
int main()
{
int n,m;cin>>n>>m;
vector<int> a(m);
vector<int> b(m);
int i;
int even=m/2;
int odd=m-even;
rep(i,odd)//1 to odd*2
{
a[i]=i+1;
b[i]=odd*2-i;
}
int add=odd*2;
rep(i,even)
{
a[odd+i]=add+i+1;
b[odd+i]=m*2+1-i;
}
rep(i,m)
{
cout<<a[i]<<' '<<b[i]<<endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vb=vector<bool>;
using vvb=vector<vb>;
using vd=vector<double>;
using vvd=vector<vd>;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using tll=tuple<ll,ll>;
using tlll=tuple<ll,ll,ll>;
using vs=vector<string>;
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define rep(i,n) range(i,0,n)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define range(i,a,n) for(ll i=(a);i<(n);i++)
#define LINF ((ll)1ll<<60)
#define INF ((int)1<<30)
#define EPS (1e-9)
#define MOD (1000000007ll)
#define fcout(a) cout<<setprecision(a)<<fixed
#define fs first
#define sc second
#define PI 3.1415926535897932384
int dx[]={1,0,-1,0,1,-1,-1,1},dy[]={0,1,0,-1,1,1,-1,-1};
template<class T>bool chmax(T&a,T b){if(a<b){a=b; return true;}return false;}
template<class T>bool chmin(T&a,T b){if(a>b){a=b; return true;}return false;}
template<class S>S acm(vector<S>&a){return accumulate(all(a),S());}
template<class S>S max(vector<S>&a){return *max_element(all(a));}
template<class S>S min(vector<S>&a){return *min_element(all(a));}
void YN(bool b){cout<<(b?"YES":"NO")<<"\n";}
void Yn(bool b){cout<<(b?"Yes":"No")<<"\n";}
void yn(bool b){cout<<(b?"yes":"no")<<"\n";}
int sgn(const double&r){return (r>EPS)-(r<-EPS);} // a>0 : sgn(a)>0
int sgn(const double&a,const double&b){return sgn(a-b);} // b<=c : sgn(b,c)<=0
ll max(int a,ll b){return max((ll)a,b);} ll max(ll a,int b){return max(a,(ll)b);}
template<class T>void puta(T&&t){cout<<t<<"\n";}
template<class H,class...T>void puta(H&&h,T&&...t){cout<<h<<' ';puta(t...);}
template<class S,class T>ostream&operator<<(ostream&os,pair<S,T>p){os<<"["<<p.first<<", "<<p.second<<"]";return os;};
template<class S>auto&operator<<(ostream&os,vector<S>t){bool a=1; for(auto s:t){os<<(a?"":" ")<<s;a=0;} return os;}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m;
cin>>n>>m;
rep(i,m){
if(n%2==0){
puta(i+1,(i+1>((m+1)/2)?n-i-1:n-i));
}
else{
puta(i+1,n-i-1);
}
}
}
| 1 |
#include<cstdio>
#include <iostream>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
#include<functional>
#include<cmath>
#include<map>
#include<stack>
#include<set>
#include<numeric>
#define rep(i,n) for(int i=0; i<int(n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int>P;
string name, str;
int length1, length2;
struct list {
int a;
int b;
int c;
int r;
};
int ok[1010];
int main() {
while (1) {
int A, B, C, N;
cin >> A >> B >> C;
if (A == 0 && B == 0 && C == 0)break;
cin >> N;
for (int i = 0; i < A + B + C; i++)
ok[i] = 2;
struct list d[1010];
for (int i = 0; i < N; i++) {
cin >> d[i].a >> d[i].b >> d[i].c >> d[i].r;
if (d[i].r) {
ok[d[i].a - 1] = 1;
ok[d[i].b - 1] = 1;
ok[d[i].c - 1] = 1;
}
}
for (int i = 0; i < N; i++) {
if (d[i].r != 1) {
if (ok[d[i].a - 1] == 1 && ok[d[i].b - 1] == 1)
ok[d[i].c - 1] = 0;
else if (ok[d[i].b - 1] == 1 && ok[d[i].c - 1] == 1)
ok[d[i].a - 1] = 0;
else if (ok[d[i].a - 1] == 1 && ok[d[i].c - 1] == 1)
ok[d[i].b - 1] = 0;
}
}
for (int i = 0; i < A + B + C; i++)
cout << ok[i] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
using uint=unsigned;
using ll=long long;
using ull=unsigned long long;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using vd=vector<double>;
using vvd=vector<vd>;
using vs=vector<string>;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
struct FenwickTree{
vector<ll> data;
FenwickTree(int n):data(n+1){}
void Add(int i,int x){
for(i++;i<data.size();i+=i&-i)
data[i]+=x;
}
ll Sum(int i){
ll res=0;
for(;i;i-=i&-i)
res+=data[i];
return res;
}
ll Sum(int i,int j){
return Sum(j)-Sum(i);
}
};
ll InversionNumber(const vi& a)
{
FenwickTree ft(a.size());
ll res=0;
rep(i,a.size()){
res+=ft.Sum(a[i],a.size());
ft.Add(a[i],1);
}
return res;
}
bool test(vector<tuple<int,int,int>> src,vector<tuple<int,int,int>> dst)
{
int n=src.size();
rep(i,n){
int x,y,z;
tie(x,y,z)=src[i];
src[i]=x<z?mt(x,y,z):mt(z,y,x);
tie(x,y,z)=dst[i];
dst[i]=x<z?mt(x,y,z):mt(z,y,x);
}
sort(all(src)); sort(all(dst));
return src==dst;
}
tuple<bool,bool> calc(vector<tuple<int,int,int>> src,vector<tuple<int,int,int>> dst)
{
int m=src.size(),flip=0;
rep(i,m){
int x,y,z;
tie(x,y,z)=src[i];
src[i]=x<z?mt(x,y,z):(flip++,mt(z,y,x));
tie(x,y,z)=dst[i];
dst[i]=x<z?mt(x,y,z):(flip++,mt(z,y,x));
}
map<tuple<int,int,int>,int> f;
rep(i,m) f[dst[i]]=i;
vi a(m);
rep(i,m) a[i]=f[src[i]];
return mt(InversionNumber(a)&1,flip&1);
}
bool solve(int n,vvi grid)
{
array<bool,2> inv,flip;
rep(i,2){
vector<tuple<int,int,int>> src,dst;
rep(j,n) if(j%2==i){
if(j/2%2==0){
src.emplace_back(mt(3*j+1,3*j+2,3*j+3));
dst.emplace_back(mt(grid[0][j],grid[1][j],grid[2][j]));
}
else{
src.emplace_back(mt(3*j+3,3*j+2,3*j+1));
dst.emplace_back(mt(grid[2][j],grid[1][j],grid[0][j]));
}
}
if(!test(src,dst)) return false;
tie(inv[i],flip[i])=calc(src,dst);
}
return inv[0]==flip[1]&&inv[1]==flip[0];
}
int main()
{
for(int n;cin>>n&&n;){
vvi grid(3,vi(n));
rep(i,3) rep(j,n) cin>>grid[i][j];
cout<<(solve(n,grid)?"Yes":"No")<<endl;
}
}
| 0 |
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
#define DEBUG true
#ifdef ONLINE_JUDGE
#undef DEBUG
#define DEBUG false
#endif
using namespace std;
#define TRACE(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); cerr << endl;}
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << "[" << *it << " = " << a << "]";
err(++it, args...);
}
#define MAXN ((int)2e5+5)
#define MOD ((int)1e9 + 7)
#define INF ((int)1e9 + 9)
#define ll long long
#define _ << " " <<
#define CLEAR(a, b) memset(a, b, sizeof(a))
#define LOG(x) if(DEBUG) cerr << x << endl;
#define pb push_back
#define all(x) x.begin(), x.end()
#define endl "\n"
#define pii pair<int,int>
#define mid ((l+r)/2)
int main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
ll ans = 0;
ll a;
double b, f;
cin >> a >> b;
ll w = b*100 + 0.01;
ans = (a*w) / 100;
cout << fixed << ans << endl;
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
*/ | #include <bits/stdc++.h>
using namespace std;
int main(){
int n, m, ans = 0;
cin >> n >> m;
ans = n * m;
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using ld = long double;
const ll ATCODER_AMARI = 1000000007; //10^9 + 7
const ll INF = 10000000000000;
//階乗関数 ATCODER_AMARIに注意
ll factorial(ll k){
ll sum = 1;
for(int i = 1 ; i < k + 1; i++) {
sum *= i;
//sum = sum % ATCODER_AMARI;
}
return sum;
}
int main() {
ll n,q;
cin >> n >> q;
string s;
cin >> s;
ll count = 0;
vector<ll> front(n,0);
rep(i,s.size()) {
if(i == 0 ) continue;
if(s.at(i - 1) == 'A' && s.at(i) == 'C') {
count++;
}
front.at(i) = count;
}
ll ans;
rep(i,q) {
ll l,r;
cin >> l >> r;
l--;
r--;
ans = front.at(r) - front.at(l);
cout << ans << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
struct StQuery
{
StQuery() : m_nLeft(0), m_nRigt(0) { }
int m_nLeft;
int m_nRigt;
};
void fnInput(string& rsStr, vector<StQuery>& rvoQuery)
{
int nStrSiz, nQuerySiz;
cin >> nStrSiz >> nQuerySiz;
rvoQuery.resize(nQuerySiz);
cin >> rsStr;
for (StQuery& roQuery : rvoQuery)
cin >> roQuery.m_nLeft >> roQuery.m_nRigt;
}
void fnSubStrACCnt(string sStr, const vector<StQuery>& cnrvoQuery)
{
const string cnsAC = "AC";
int nACCnt = 0;
vector<int> vnACCnt(sStr.size());
for (int nBgn = 0; nBgn < vnACCnt.size() - 1; nBgn++)
{
if (sStr.substr(nBgn, 2) == cnsAC) nACCnt++;
vnACCnt[ nBgn + 1 ] = nACCnt;
}
for (int i = 0; i < cnrvoQuery.size(); i++)
{
cout << vnACCnt[ cnrvoQuery[i].m_nRigt - 1 ] - vnACCnt[ cnrvoQuery[i].m_nLeft - 1];
cout << endl;
}
}
int main()
{
string sStr;
vector<StQuery> voQuery;
fnInput(sStr, voQuery);
fnSubStrACCnt(sStr, voQuery);
return 0;
} | 1 |
#include <iostream>
#include <queue>
#include <functional>
#include <vector>
using namespace std;
struct edge {
int to;
int cost;
};
typedef pair<int, int> P;
int V;
vector<edge> G[3010];
vector<edge> G2[3010];
int d[3010];
void dijkstra(int s, int h) {
priority_queue<P, vector<P>, greater<P> > que;
fill(d, d+V, 10000000);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first) {
continue;
}
if (h == 0) {
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
} else {
for (int i = 0; i < G2[v].size(); i++) {
edge e = G2[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
}
}
int main() {
int n, m;
while (cin >> n >> m) {
if (n == 0 && m == 0) {
break;
}
for (int i = 1; i <= m; i++) {
G[i].clear();
G2[i].clear();
}
V = m+1;
int a, b, time, cost;
for (int i = 0; i < n; i++) {
cin >> a >> b >> cost >> time;
edge e;
e.to = b;
e.cost = cost;
G[a].push_back(e);
e.to = a;
G[b].push_back(e);
e.to = b;
e.cost = time;
G2[a].push_back(e);
e.to = a;
G2[b].push_back(e);
}
int w;
cin >> w;
int p, q, r;
for (int i = 0; i < w; i++) {
cin >> p >> q >> r;
dijkstra(p, r);
cout << d[q] << endl;
}
}
return 0;
} | #include <stdio.h>
#define MAXN 105
typedef struct _pair {
int id, score;
} pair;
int N;
pair arr[MAXN];
int rank[MAXN];
void bubleSort() {
int i, j;
pair p;
for(i = 0; i < N; ++i) {
for(j = 1; j < N-i; ++j) {
if(arr[j-1].score < arr[j].score) {
p = arr[j-1];
arr[j-1] = arr[j];
arr[j] = p;
}
}
}
}
int main() {
int i, j;
int A, B, C, D;
scanf("%d", &N);
for(i = 0; i < N; ++i) {
arr[i].id = i;
arr[i].score = 0;
}
for(i = 0; i < N*(N-1)/2; ++i) {
scanf("%d %d %d %d", &A, &B, &C, &D);
--A; --B;
if(C == D) {
arr[A].score += 1;
arr[B].score += 1;
} else if(C > D) {
arr[A].score += 3;
} else if(C < D) {
arr[B].score += 3;
}
}
bubleSort();
for(i = 0, j = 1; i < N; ++i) {
if(i-1 >= 0 && arr[i].score == arr[i-1].score) {
} else {
j = i+1;
}
rank[arr[i].id] = j;
}
for(i = 0; i < N; ++i) {
printf("%d\n", rank[i]);
}
return 0;
} | 0 |
#include<cstdio>
#include<cstring>
#include<vector>
#include<map>
#include<cmath>
#include<algorithm>
#define N 2005
#define MOD 998244353
using namespace std;
int k,n;
int a[N];
int d[N][N];
int dy[N][N];
int main() {
scanf("%d%d", &k,&n);
int i, j;
for (i = 1; i <= k; i++) d[1][i] = 1;
for (i = 2; i <= n; i++) {
int sum = 0;
for (j = 1; j <= k; j++) {
sum += d[i - 1][j]; sum %= MOD;
d[i][j] = sum;
}
}
dy[0][0] = 1;
dy[1][0] = k;
for (i = 1; i <= k; i++) {
dy[0][i] = 1; dy[1][i] = k;
}
for (i = 2; i <= n; i++) {
for (j = 1; j <= k; j++) {
dy[i][0] += d[i][j]; dy[i][0] %= MOD;
}
for (int ban = 1; ban <= k; ban++) {
dy[i][ban] = dy[i][ban - 1] - dy[i - 2][ban - 1];
if (dy[i][ban] < 0) dy[i][ban] += MOD;
}
}
for (i = 2; i <= k+1 ; i++) {
printf("%d\n", dy[n][i / 2]);
}
for (i = k ; i >= 2; i--) printf("%d\n", dy[n][i / 2]);
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const double EPS = 1e-10;
bool used[4001];
ll fact[4001], inv_fact[4001];
ll comb(ll n, ll k) {
if (n < k) return 0;
ll ret = fact[n];
(ret *= inv_fact[k]) %= MOD;
(ret *= inv_fact[n - k]) %= MOD;
return ret;
}
ll mod_pow(ll a, ll b) {
if (b == 0) return 1;
if (b % 2 == 0) {
ll x = mod_pow(a, b / 2);
return (x*x) % MOD;
}
return (a*mod_pow(a, b - 1)) % MOD;
}
int main() {
int K, N;
cin >> K >> N;
fact[0] = 1;
inv_fact[0] = 1;
for (int i = 1; i <= 4000; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
inv_fact[i] = (inv_fact[i - 1] * mod_pow(i, MOD - 2)) % MOD;
}
for (int i = 2; i <= 2 * K; i++) {
memset(used, 0, sizeof(used));
int x = 0, y = 0;
for (int j = 1; j <= K; j++) {
if (used[j]) continue;
used[j] = 1;
if (1 <= i - j && i - j <= K) {
if (!used[i - j]) {
used[i - j] = 1;
y++;
}
}
else {
x++;
}
}
ll ans = 0;
for (int j = 0; j <= min(N, y); j++) {
ll t = comb(y, j);
(t *= mod_pow(2, j)) %= MOD;
(t *= comb(N + x - 1, N - j)) %= MOD;
(ans += t) %= MOD;
}
if (i % 2 == 0) {
for (int j = 0; j <= min(N - 1, y); j++) {
ll t = comb(y, j);
(t *= mod_pow(2, j)) %= MOD;
(t *= comb(N + x - 2, N - 1 - j)) %= MOD;
(ans += t) %= MOD;
}
}
cout << ans << endl;
}
} | 1 |
#include<bits/stdc++.h>
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
using namespace std;
#define N 305
int n,k,f[N][N][N];char s[N];
int dp(int l,int r,int k){
if (k<0) return -1000;
if (l>r) return 0;
int &res=f[l][r][k];
if (~res) return res;
if (l==r) return res=1;
res=0;
if (s[l]==s[r]) res=max(res,dp(l+1,r-1,k)+2);
else res=max(res,max(max(dp(l+1,r,k),dp(l,r-1,k)),dp(l+1,r-1,k-1)+2));
return res;
}
int main(){
scanf("%s%d",s+1,&k);n=strlen(s+1);
memset(f,-1,sizeof(f));
printf("%d\n",dp(1,n,k));
return 0;
} | #include<map>
#include<set>
#include<bitset>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<chrono>
#include<stack>
#include<fstream>
#include<math.h>
#include<list>
#include<complex>
#define REP(i,x,y) for(ll i=x;i<=y;i++)
#define SIZE(a) ll(a.size())
#define vll vector<ll>
#define vvll vector<vector<ll>>
#define vtype(type) vector<type>
#define vvtype(type) vector<vector<type>>
#define MEMSET(a, n, m) for(ll i=0;i<=n;i++) a[i] = m
#define BIT(n) (ll(1)<<n)
#define UNIQUE(v) v.erase(unique(v.begin(),v.end()),v.end())
#define UNIQUE_ARRAY(a,x) unique(a + 1, a + x + 1) - a - 1
#define SORT(a,n) sort(a+1,a+n+1)
#define SORT_O(a,n,order) sort(a+1,a+n+1,order)
#define PER(i,y,x) for(ll i=y;i>=x;i--)
typedef long long ll;
using namespace std;
struct wall
{
long long r; ll c;
bool operator<(const wall& rhs) const {
if (r != rhs.r) {
return r < rhs.r;
}
else {
return c < rhs.c;
}
}
};
ll const MOD = 998244353;
ll mod_p(ll x, ll y) {
//x %= MOD;
//y %= MOD;
return (x + y + MOD) % MOD;
}
ll mod_m(ll x, ll y) {
x %= MOD;
y %= MOD;
return x * y%MOD;
}
ll mod_pow(ll x, ll t) {
x %= MOD;
if (t == 0) {
return 1;
}
else {
ll v = mod_pow(x, t / 2);
if (t % 2 == 0) {
return v * v % MOD;
}
else {
return v * v%MOD * x %MOD;
}
}
}
ll mod_inv(ll x) {
return mod_pow(x, MOD - 2);
}
vll fct(1e7 + 5);
vll fct_inv(1e7 + 5);
void fct_init() {
fct[0] = fct_inv[0] = 1;
REP(i, 1, 1e6) {
fct[i] = mod_m(fct[i - 1], i);
fct_inv[i] = mod_inv(fct[i]);
}
}
ll c(ll n, ll r) {
return mod_m(fct[n], mod_m(fct_inv[r], fct_inv[n - r]));
}
ll h(ll n, ll r) {
return c(n - 1 + r, r - 1);
}
ll f(ll n, ll k, ll t, ll x) {
ll ans = 0;
ll sign = 1;
REP(i, 0, x) {
ll tmp = 0;
if (n - 2 * i < 0) {
break;
}
// cout << "h " << h(n - 2 * i, k) << " " << c(x, i) << endl;
tmp = mod_m(h(n - 2 * i, k), c(x, i));
ans = mod_p(ans, sign*tmp);
sign *= -1;
//cout << ans << "?" << endl;
}
return ans;
}
int main() {
ll n, k;
cin >> k >> n;
if (k == 1) {
cout << 0 << endl;
return 0;
}
fct_init();
REP(t, 2, 2 * k) {
ll x = 0;
REP(i, 1, t) {
ll j = t - i;
if (i < j && j <= k) {
x++;
}
if (i >= j) break;
}
//cout << x << "!" << endl;
if (t % 2 == 1) {
ll ans = f(n, k, t, x);
cout << ans << endl;
}
else {
ll u = f(n, k - 1, t, x);
ll v = f(n - 1, k - 1, t, x);
ll ans = mod_p(u, v);
cout << ans << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> s(N);
for( int i = 0; i < N; i++ ) {
cin >> s.at(i);
}
int M;
cin >> M;
vector<string> t(M);
for( int i = 0; i < M; i++ ) {
cin >> t.at(i);
}
vector<int> count(N);
for ( int i = 0; i < N; i++ ) {
for( int j = 0; j < N; j ++ ) {
if (s.at(i) == s.at(j) ) {
count.at(i)++;
}
}
for ( int j = 0; j < M; j++ ) {
if (s.at(i) == t.at(j) ) {
count.at(i)--;
}
}
}
int max = 0;
for( int i = 0; i < N; i++ ) {
if( count.at(i) > max ) {
max = count.at(i);
}
}
cout << max << endl;
} | #include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
//using namespace boost::multiprecision;
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> P;
#define PI 3.141592653589793
#define MOD 1000000007
//#define MOD 998244353
#define ALL(obj) (obj).begin(),(obj).end()
template<class T>inline bool chmax(T& a,T b){if (a<b){a=b;return 1;}return 0;}
template<class T>inline bool chmin(T& a,T b){if (a>b){a=b;return 1;}return 0;}
const ll INF = 1LL << 60;
//四方向への移動ベクトル
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct edge{//グラフに使うヤツ
ll from,to,cost;
};
typedef vector<vector<edge> > G;
ll gcd(ll a,ll b){
if (a%b==0)return(b);
else return(gcd(b,a%b));
}
int main() {
ll n,m;
cin >> n;
map<string,ll> red;
map<string,ll> blue;
for (ll i=0;i<n;i++){
string a;
cin >> a;
if (blue.count(a)){
blue[a]++;
}else{
blue[a]=1;
}
}
cin >> m;
for (ll i=0;i<m;i++){
string a;
cin >> a;
if (red.count(a)){
red[a]++;
}else{
red[a]=1;
}
}
ll ans=0;
for (auto b: blue){
string s=b.first;
if (blue[s]>red[s]){
ans=max(ans,blue[s]-red[s]);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1; i <= (int)(n); i++)
int main(){
int N;
cin >> N;
for (int i = N; i > 0; i--)
{
if (sqrt(i) == floor(sqrt(i))){
cout << i << endl;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define rrep(i,n) for (int i=n;^i;i--)
#define ALL(v) v.begin(),v.end()
// #define int ll
#define eps 1e-9
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
template<class T> inline void chmax(T &a, const T &b) { if(a < b) a = b; }
template<class T> inline void chmin(T &a, const T &b) { if(a > b) a = b; }
typedef long long ll;
signed main(void){
ll sum;
int d;
while(cin>>d){
sum = 0;
for(int i=0;i<600;i+=d) sum += d*(i*i);
cout << sum << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
while(true){
int n,p;
cin >> n >> p;
if(n == 0){
break;
}
int maxp = p;
list<pair<int,int> > l;
for(int i=0; i<n; i++){
l.push_back(make_pair(0,i));
}
list<pair<int,int> >::iterator itr = l.begin();
while(true){
if(p > 0){
p--;
itr->first++;
if(itr->first == maxp){
cout << itr->second << endl;
break;
}
}
else{
p += itr->first;
itr->first = 0;
}
itr++;
if(itr == l.end()){
itr = l.begin();
}
}
}
return 0;
}
| #include <bits/stdc++.h>
#if ((_WIN32 || __WIN32__) && __cplusplus < 201103L)
#define lld I64d
#else
#define lld lld
#endif
//{{{
using namespace std;
typedef long long LL;
typedef vector<int> VI;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define clr(a, b) memset(a, b, sizeof(a))
// clang-format off
#define debug(args...) {vector<string> _v = split(#args, ','); err(_v.begin(), args); cerr<<endl;}
vector<string> split(const string& s, char c) {vector<string> v; stringstream ss(s); string x; while
(getline(ss, x, c)) v.push_back(x); return v;} void err(vector<string>::iterator) {}
template<typename T, typename... Args> void err(vector<string>::iterator it, T a, Args... args)
{cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << ", "; err(++it, args...);}
// clang-format on
//}}}
int a[22][22];
int n;
LL dp[1 << 16];
LL dfs(int st)
{
if (dp[st] != -1) return dp[st];
if (__builtin_popcount(st) == 1)
{
return dp[st] = 0;
}
LL ret = 0;
for (int i = 0; i < n; i++)
{
if ((st & (1 << i)) == 0) continue;
for (int j = i + 1; j < n; j++)
{
if ((st & (1 << j)) == 0) continue;
ret += a[i][j];
}
}
for (int i = st; i; i = (i - 1) & st)
{
if (i == st) continue;
int st1 = i;
int st2 = st ^ i;
LL v = dfs(st1) + dfs(st2);
if (v > ret) ret = v;
}
return dp[st] = ret;
}
int main()
{
#ifdef LOCAL
freopen("in", "r", stdin);
// freopen("out", "w", stdout);
#endif
while (cin >> n)
{
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
clr(dp, -1);
dp[0] = 0;
int lim = (1 << n) - 1;
LL ans = dfs(lim);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <cstdio>
typedef long long ll;
#define ri register int
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
// getchar
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
// print the remaining part
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
// putchar
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
// input a signed integer
template <class I>
inline void gi (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = (x << 1) + (x << 3) + (c & 15); x *= f;
}
// print a signed integer
template <class I>
inline void print (I x) {
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
//no need to call flush at the end manually!
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: gi;
using io :: putc;
using io :: print;
const int N=605;
int n,m,col1[N][N],col2[N][N],tag[2][2];
inline void solve(ri d,int col[N][N]){
ri i,j,k;
k=0;
while(d%4==0) d>>=2,++k;
if(d&1){
for(i=0;i<m;++i)
for(j=0;j<m;++j)
if((i>>k)+(j>>k)&1)
col[i][j]=1;
}
else{
for(i=0;i<m;++i)
for(j=0;j<m;++j)
if((i>>k)&1)
col[i][j]=1;
}
}
int main(){
ri d1,d2,i,j,x,y,cnt;
gi(n);gi(d1);gi(d2);
m=n<<1;
solve(d1,col1);
solve(d2,col2);
for(i=0;i<m;++i)
for(j=0;j<m;++j)
++tag[col1[i][j]][col2[i][j]];
for(i=0;i<=1;++i)
for(j=0;j<=1;++j)
if(tag[i][j]>=n*n){
cnt=0;
for(x=0;x<m;++x)
for(y=0;y<m;++y)
if(col1[x][y]==i&&col2[x][y]==j){
print(x);putc(' ');print(y);putc('\n');
if(++cnt==n*n) return 0;
}
}
} | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n,m,q;
ll res;
vector<ll> v;
while(true) {
cin >> n >> m;
if(n == 0) break;
v.clear();
res = 0;
for(int i = 0; i < n; i++){
cin >> q;
v.push_back(q);
}
sort(v.begin(), v.end(), greater<int>());
for(int i=0; i < n; i++) {
if(i % m != m - 1)
res += v[i];
}
cout << res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main()
{
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
ld res = n / ld(min({a, b, c, d, e}));
cout << (ll (ceil(res) + 4)) << "\n";
return 0;
}
| #include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <cstring>
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <numeric>
#include <float.h>
#include <math.h>
#include <sstream>
#include <iterator>
using namespace std;
// repマクロの定義
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// allマクロの定義
#define all(v) v.begin(), v.end()
// 大きい順
#define rall(v) v.rbegin(), v.rend()
#define vi vector<int>
#define vl vector<ll>
const long long INF = 1LL << 60;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int ctoi(char c) {
switch (c) {
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
default: return 0;
}
}
bool is_prime(const unsigned n){
switch(n){
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if(n % 2 == 0 || n % 3 == 0) return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for(unsigned i = 5; i * i <= n; i += 6) {
if(n % i == 0) return false; // (6の倍数)-1
if(n % (i+2) == 0) return false; // (6の倍数)+1
}
return true;
}
map<ll,ll> mp;
auto findFactors(ll num){
ll i;
while (num % 2 == 0){ // 偶数の素数は2のみ
if(mp.count(2)){
mp[2] = mp[2] + 1;
}
else{
mp[2] = 1;
}
num /= 2;
}
for (i = 3; i <= num; i++){ // 他の素数で割っていく
while (num % i == 0){
if(mp.count(i)){
mp[i] = mp[i] + 1;
}
else{
mp[i] = 1;
}
num /= i;
}
}
return 0;
}
ll kaizyou(ll n){
if(n == 1){
return 1;
}
else{
return (n * kaizyou(n-1)) % 1000000007;
}
}
int main(){
int N; cin >> N;
map<ll,ll> A;
rep(i,N) {
ll a; cin >> a;
if(!A.count(a)){
A[a] = 1;
}
else{
A[a] += 1;
}
}
vl x;
for(auto u:A){
if(u.second >= 2){
x.push_back(u.first);
}
if(u.second >= 4){
x.push_back(u.first);
}
}
if(x.size() >= 2){
sort(rall(x));
cout << x[0] * x[1] << endl;
}
else{
cout << 0 << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < b) || (b < c && c < a))
cout << "Yes";
else
cout << "No";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
vector<int> A(3);
cin >> A[0] >> A[1] >> A[2];
int mid = A[2];
sort(A.begin(), A.end());
cout << (A[1]==mid?"Yes":"No") << endl;
return 0;
} | 1 |
#include<iostream>
using namespace std;
int main(void){
long long n,a[10000],min=1000000,max=-1000000,sum=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
if(a[i]<min){min=a[i];}
if(a[i]>max){max=a[i];}
sum=a[i]+sum;
}
cout<<min<<" "<<max<<" "<<sum<<endl;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <numeric>
#include <ctime>
#include <complex>
#include <bitset>
#include <random>
#include <stack>
using namespace std;
typedef long long ll;
typedef long double ld;
#define int ll
#define double ld
#define loop(i, n) for(int i = 0; i < (int)n; ++i)
#define loop1(i, n) for(int i = 1; i <= (int)n; ++i)
#define F first
#define S second
#define pb push_back
#define pi pair <int, int>
#define all(x) begin(x), end(x)
#define ti tuple <int, int, int>
#define Point Vect
#define mkt make_tuple
#define no {cout << -1; return;}
void solve() {
int p, q, r;
cin >> p >> q >> r;
cout << min({ p + q, q + r, p + r });
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//int t; cin >> t; loop(i, t)
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// __uint128_t
const ll MOD = 1e9+7;
int main(){
ll N, M, Q; cin >> N >> M >> Q;
vector<vector<ll>> D(N+1, vector<ll>(N+1));
for(int i = 0; i < M; i++){
ll l, r; cin >> l >> r; D[l][r]++;
}
for(int i = 0; i < N+1; i++){
for(int j = 0; j < N; j++) D[i][j+1] += D[i][j];
}
while(Q--){
ll p, q; cin >> p >> q;
ll cnt = 0;
for(;p <= q; p++){
cnt += D[p][q];
}
cout << cnt << endl;
}
}
| ///Bismillahir Rahmanir Rahim
#include<bits/stdc++.h>
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll,ll>
#define clr(x) memset(x,0,sizeof(x));
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define show(x,y) cout<<x<<" : ";for(auto z:y)cout<<z<<" ";cout<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const ll inf=1e18;
const int mod=1e9+7;
struct BIT
{
int N;
vector<int> bit;
void init(int n)
{
N = n;
bit.assign(n + 1, 0);
}
void update(int idx, int val)
{
while(idx <= N)
{
bit[idx] += val;
idx += idx & -idx;
}
}
void updateMax(int idx, int val)
{
while(idx <= N)
{
bit[idx] = max(bit[idx], val);
idx += idx & -idx;
}
}
int pref(int idx)
{
int ans = 0;
while(idx > 0)
{
ans += bit[idx];
idx -= idx & -idx;
}
return ans;
}
int rsum(int l, int r)
{
return pref(r) - pref(l - 1);
}
int prefMax(int idx)
{
int ans = -2e9;
while(idx > 0)
{
ans = max(ans, bit[idx]);
idx -= idx & -idx;
}
return ans;
}
};
const int M=502;
vector<int>vec[M];
int ses[100009];
vector<pi>yo[M];
vector<pi>abr_yo[M];
BIT Magic;
main()
{
fast
int n,m,q;
cin>>n>>m>>q;
Magic.init(503);
f(i,1,m)
{
int l,r;
cin>>l>>r;
vec[l].pb(r);
}
f(i,1,q)
{
int l,r;
cin>>l>>r;
yo[l].pb(mp(r,i));
abr_yo[r].pb(mp(l,i));
}
f(i,1,500)
{
for(auto x:yo[i])
{
int idx=x.si;
int rgt=x.fi;
int lft=i;
ses[idx]=-Magic.rsum(lft,rgt);
}
for(auto x:vec[i])
{
Magic.update(x,1);
}
}
Magic.init(503);
f(i,1,500)
{
for(auto x:vec[i])
{
Magic.update(x,1);
}
for(auto x:abr_yo[i])
{
int idx=x.si;
int lft=x.fi;
int rgt=i;
ses[idx]+=Magic.rsum(lft,rgt);
}
}
f(i,1,q)
{
cout<<ses[i]<<endl;
}
cout<<endl;
return 0;
}
| 1 |
// clang-format off
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
// clang-format on
const ll INF = LLONG_MAX / 3;
int main() {
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
const int L = 2 + n % 2;
vector<vector<ll>> dp(n, vector<ll>(L, -INF));
rep(i, L) dp[i][L - 1 - i] = a[i];
rep(i, n - 1) rep(j, L) {
if (dp[i][j] == -INF) continue;
if (i + 2 < n) dp[i + 2][j] = max(dp[i + 2][j], dp[i][j] + a[i + 2]);
if (j > 0) dp[i + 1][j - 1] = max(dp[i + 1][j - 1], dp[i][j]);
}
cout << dp[n - 1][0] << "\n";
return 0;
}
| #include <stdio.h>
const int bias = 10;
long long dp[bias*2+1][2],nxt[bias*2+1][2];
void mx(long long &a, long long b)
{
if (a < b) a = b;
}
int main()
{
for (int i=0;i<=bias*2;i++) dp[i][0] = dp[i][1] = -1e18; dp[bias][0] = 0;
int n; scanf ("%d",&n);
for (int k=0;k<n;k++){
int x; scanf ("%d",&x);
for (int i=0;i<=bias*2;i++) nxt[i][0] = nxt[i][1] = -1e18;
for (int i=0;i<=bias*2;i++){
mx(nxt[i][0],dp[i][0]);
mx(nxt[i][0],dp[i][1]);
mx(nxt[i+2][1],dp[i][0]+x);
}
for (int i=1;i<=bias*2;i++){
dp[i-1][0] = nxt[i][0];
dp[i-1][1] = nxt[i][1];
}
dp[bias*2][0] = dp[bias*2][1] = -1e18;
}
int last = (n / 2) * 2 - n + bias;
long long ans = -1e18;
mx(ans,dp[last][0]);
mx(ans,dp[last][1]);
printf ("%lld\n",ans);
return 0;
}
| 1 |
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
using namespace std;
class Dice {
private:
int surface [6];
void next(int a, int b, int c, int d);
public:
Dice(int surface[6]);
Dice();
void role(char dir);
void set(int pos, int num);
int get(int pos);
};
int main(void) {
Dice dice;
for (int i = 0; 6 > i; i++) {
int buf;
scanf("%d", &buf);
dice.set(i, buf);
}
char order;
while (scanf(" %c", &order) != EOF) {
dice.role(order);
}
printf("%d\n", dice.get(0));
return 0;
}
void Dice::next(int a, int b, int c, int d)
{
swap(surface[c], surface[d]);
swap(surface[b], surface[c]);
swap(surface[a], surface[b]);
}
Dice::Dice(int surface[6])
{
for (int i = 0; 6 > i; i++)
Dice::surface[i] = surface[i];
}
Dice::Dice()
{
for (int i = 0; 6 > i; i++) surface[i] = 0;
}
void Dice::role(char dir)
{
switch (dir) {
case 'W': next(0,3,5,2); break;
case 'E': next(0,2,5,3); break;
case 'N': next(0,4,5,1); break;
case 'S': next(0,1,5,4); break;
}
}
void Dice::set(int pos, int num)
{
surface[pos] = num;
}
int Dice::get(int pos)
{
return surface[pos];
} | #include<bits/stdc++.h>
using namespace std;
struct Dice
{
int x, y;
int l, r, f, b, d, u;
void RollF()
{
--y;
int buff = d;
d = f;
f = u;
u = b;
b = buff;
}
void RollB()
{
++y;
int buff = d;
d = b;
b = u;
u = f;
f = buff;
}
void RollL()
{
--x;
int buff = d;
d = l;
l = u;
u = r;
r = buff;
}
void RollR()
{
++x;
int buff = d;
d = r;
r = u;
u = l;
l = buff;
}
};
int main()
{
Dice dice;
cin >> dice.u;
cin >> dice.f;
cin >> dice.l;
cin >> dice.r;
cin >> dice.b;
cin >> dice.d;
string S;
cin >> S;
for(char &c : S) {
if(c == 'S') dice.RollF();
else if(c == 'N') dice.RollB();
else if(c == 'W') dice.RollR();
else dice.RollL();
}
cout << dice.u << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
int M = 0;
cin >> M;
vector<int> s(M,0);
vector<int> c(M,0);
if(M == 0) {
cout << (int)pow(10, N - 1)*(N != 1) << endl;
return 0;
}
for(int i = 0; i < M; i++) {
cin >> s.at(i);
cin >> c.at(i);
}
for(int i = pow(10, N - 1)*(N != 1); i < pow(10, N); i++) {
int check = 1;
for(int j = 0; j < M; j++) {
if((i/(int)pow(10, N - s.at(j)))%10 == c.at(j)) {
continue;
}
check = 0;
}
if(check) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
int n,m;cin>>n>>m;
vector<pair<int,int>> pr(m);
rep(i,m){
int s,c;cin>>s>>c;
s--;
pr[i]=make_pair(s,c);
}
rep(i,1000){
bool ans=true;
string a=to_string(i);
int keta=a.size();
if(n!=keta)continue;
rep(j,m){
if(a[pr[j].first]!=(char)('0'+pr[j].second))ans=false;
}
if(ans){
cout<<i<<endl;
return 0;
}
}
cout<<-1<<endl;
} | 1 |
#include <iostream>
using namespace std;
#include <vector>
#include <functional>
template<class T, class Lazy> struct LazySegTree {
private:
public:
int size;
vector<T> v; vector<Lazy> lazy;
vector<int> seg_size;
using F = function<T(T,T)>;
using G = function<Lazy(Lazy,Lazy)>;
using H = function<T(T,Lazy,int)>;
F f; G g; H h;
T default_value; Lazy default_lazy;
public:
LazySegTree(int n, T default_value, Lazy default_lazy, F f, G g, H h)
: default_value(default_value), default_lazy(default_lazy), f(f), g(g), h(h) {
size = 1;
while (size < n) size *= 2;
v.resize(2 * size - 1, default_value);
lazy.resize(4 * size - 1, default_lazy);
seg_size.resize(2 * size - 1, 1);
for (int i = 0; i < size - 1; ++i) {
int j = size - 2 - i;
seg_size[j] = seg_size[2 * j + 1] + seg_size[2 * j + 2];
}
}
void update(int index, T val) {
update(index, index+1, default_lazy);
index = index + size - 1;
v[index] = val;
while (index > 0) {
index = (index - 1) / 2;
v[index] = f(v[2 * index + 1], v[2 * index + 2]);
}
}
void eval(int index) {
v[index] = h(v[index], lazy[index], seg_size[index]);
lazy[2 * index + 1] = g(lazy[index], lazy[2 * index + 1]);
lazy[2 * index + 2] = g(lazy[index], lazy[2 * index + 2]);
lazy[index] = default_lazy;
}
T query(int l, int r) { return query(l, r, 0, size, 0); }
T query(int l, int r, int cur_l, int cur_r, int index) {
// [l, r)に対するクエリ
eval(index);
if (cur_r <= l || r <= cur_l) return default_value;
if (l <= cur_l && cur_r <= r) return v[index];
// 左右を見ていく
int mid = (cur_l + cur_r) / 2;
return f(
query(l, r, cur_l, mid, 2 * index + 1),
query(l, r, mid, cur_r, 2 * index + 2));
}
void update(int l, int r, Lazy x) { update(l, r, x, 0, size, 0); }
void update(int l, int r, Lazy x, int cur_l, int cur_r, int index) {
// [l, r)に対して操作する
eval(index);
if (cur_r <= l || r <= cur_l) return;
if (l <= cur_l && cur_r <= r) {
lazy[index] = x;
eval(index);
return;
}
// 左右を見ていく
int mid = (cur_l + cur_r) / 2;
update(l, r, x, cur_l, mid, 2 * index + 1);
update(l, r, x, mid, cur_r, 2 * index + 2);
v[index] = f(v[2 * index + 1], v[2 * index + 2]);
}
};
// // 範囲和
// LazySegTree<long long, int> T(N, 0, 0,
// [](long long a, long long b) {return a + b;},
// [](int a, int b) {return a + b;},
// [](long long a, int b, int size) {return a + b * size;});
// // chmin
// LazySegTree<ll, ll> T(N, INF, -1,
// [](ll a, ll b) {return min(a, b);},
// [](ll a, ll b) { return a == -1 ? b : a;},
// [](ll a, ll lz, int size) {return lz == -1 ? a : lz;});
#define in(v) v; cin >> v;
void ins() {}
template<class T,class... Rest>void ins(T& v,Rest&... rest){cin>>v;ins(rest...);}
#define rep(i,n) for(int i=0,_i=(n);i<_i;++i)
int main() {
int in(N); int in(Q);
// 範囲和
LazySegTree<int, int> T(N, 2147483647, -1,
[](int a, int b) {return min(a, b);},
[](int par_lz, int lz) {return par_lz == -1 ? lz : par_lz;},
[](int a, int lz, int size) {return lz == -1 ? a : lz;});
rep(i, Q) {
int com;
ins(com);
if (com == 0) {
int s, t, x;
ins(s, t, x);
++t;
T.update(s, t, x);
} else {
int in(idx);
cout << T.query(idx, idx+1) << endl;
}
}
return 0;
}
| #include<bits/stdc++.h>
//#define int long long
#define endl '\n'
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define bug1( x ) {cerr << (#x) <<"="<< x << endl;}
#define bug2( x , y ) {cerr << (#x) <<"="<< (x) << " " << (#y) << "="<< (y) << endl;}
#define bug3( x , y , z ) {cerr << (#x) <<"="<<(x) << " " << (#y) <<"="<< (y) << " " << (#z) <<"="<< (z) << endl;}
#define bug4( x , y , z , w) {cerr << (#x) <<"="<<(x) << " " << (#y) <<"="<< (y) << " " << (#z) <<"="<< (z) << " " << (#w) <<"="<< w << endl;}
#define bug5( x , y , z , w ,p) {cerr << (#x) <<"="<<(x) << " " << (#y) <<"="<< (y) << " " << (#z) <<"="<< (z) << " " << (#w) <<"="<< w << " " << (#p) <<"="<< p << endl;}
#define bug6( x , y , z , w ,p , q) {cerr << (#x) <<"="<<(x) << " " << (#y) <<"="<< (y) << " " << (#z) <<"="<< (z) << " " << (#w) <<"="<< w << " " << (#p) <<"="<< p << " " << (#q) <<"="<< q << endl;}
#define bugn( x , n ) {cerr << (#x) <<":";for(int i=0;i<n;i++)cerr << x[i] <<" "; cerr << endl;}
#define bugnm( x , n , m ) {cerr << (#x)<<endl;for(int i=0;i<n;i++){cerr << "Row #" << i<< ":";for(int j=0;j<m;j++)cerr << x[i][j] << " ";cerr << endl;}}
typedef long long ll;
typedef long double ld;
using namespace std;
const int maxn = 1e6+10;
int dp[maxn][10];
string s;
int n;
int solve(int i,int carry){
//bug2(i,carry);
if( i >= n )return carry;
int & ans = dp[i][carry%10];
if( ans != -1 )return carry/10 + ans;
ans = 1e8;
carry += ( i < n ? s[i]-'0' : 0 );
ans = min( ans , carry % 10 + solve(i+1,carry/10) );
if( carry%10 ){
ans = min( ans , 10-(carry%10) + solve(i+1,carry/10 + 1));
}
return ans;
}
int32_t main(){
IOS
memset(dp,-1,sizeof(dp));
cin >> s; reverse(s.begin(),s.end());
n = s.length();
cout << solve(0,0) ;
}
/*
* long long or int?
* index out of bound?
* Tested on own test case?corner?
* Make more general solution.
* Read Read Read Read ....
*/
| 0 |
#include <bits/stdc++.h>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <iostream>
#include <bitset>
#include <cassert>
#include <queue>
#include <random>
#include <stack>
#include <iomanip>
#include <math.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define repf(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define repr(i, a, b) for (ll i = (ll)a; i > (ll)b; i--)
#define repv(x, arr) for (auto &x : arr)
#define all(v) (v).begin(), (v).end()
#define vec(name, num) vector<ll> name((num), 0);
#define mp(a, b) make_pair(a, b)
#define F first
#define S second
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<int> vii;
typedef vector<vii> vvii;
const ll mod = 1e9 + 7;
const int infi = 2147483600;
const ll infl = 1e17;
int n,m;
int main()
{
cin >> n >> m;
vii a(n), b(m);
rep(i, n) cin >> a[i];
rep(i, m) cin >> b[i];
sort(all(a));
sort(all(b));
rep(i, n - 1)
{
if (a[i] == a[i + 1])
{
cout << 0 << endl;
return 0;
}
}
rep(i, m - 1)
{
if (b[i] == b[i + 1])
{
cout << 0 << endl;
return 0;
}
}
ll ans = 1;
repr(now,n*m,0){
int aidx = lower_bound(all(a), now) - a.begin();
int bidx = lower_bound(all(b), now) - b.begin();
ll atar = n - aidx, btar = m - bidx;
ll kimeta = n * m - now;
if (a[aidx]==now && b[bidx]==now){
continue;
}
else if(a[aidx]==now){
ans = (ans * btar) % mod;
}
else if(b[bidx]==now){
ans = (ans * atar) % mod;
}
else {
ans = (ans * ((atar * btar) % mod + mod - kimeta) % mod) % mod;
}
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) ((v).begin(), (v).end())
using ll = long long;
using P = pair<int, int>;
/* ------------------------------------------------ */
ll fact(int i) { //階乗
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
ll gcd(ll a, ll b) { //最大公約数
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a * b / gcd(a, b);
}
int keta(ll n) { //桁数を求める
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ------------------------------------------------ */
int main() {
int h,w;
cin >> h >> w;
char s[55][55];
rep(i, h) {
rep(j, w) cin >> s[i][j];
}
int dist[55][55];
rep(i, h) {
rep(j, w) dist[i][j] = -1;
}
dist[0][0] = 1;
int f[]={0,1,0,-1};
int g[]={1,0,-1,0};
queue<P> que;
que.push({0,0});
while(!que.empty()) {
P p = que.front();
que.pop();
rep(i, 4) {
int x = p.first + f[i],y = p.second + g[i];
if(x > h-1 || x < 0 || y > w-1 || y < 0) continue;
if(dist[x][y] == -1 && s[x][y] == '.'){
dist[x][y] = dist[p.first][p.second]+1;
que.push({x,y});
}
}
}
if(dist[h-1][w-1]==-1) {
cout << -1 << endl;
return 0;
}
int ans = h*w - dist[h - 1][w - 1];
rep(i, h) {
rep(j, w) if(s[i][j] == '#') ans--;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define ld long double
#define pb push_back
#define all(x) (x).begin(), (x).end()
template <typename T> using ord_set = tree <T, null_type, less <T>, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 123;
int n, a[N];
array <ll, 2> p[N], s[N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int j = 1;
ll pref = a[1], cur = a[1];
for (int i = 2; i <= n; i++) {
pref += a[i];
while (abs(cur + a[j + 1] - (pref - cur - a[j + 1])) < abs(cur - (pref - cur)))
cur += a[++j];
p[i] = {cur, pref - cur};
if (p[i][0] > p[i][1]) swap(p[i][0], p[i][1]);
}
ll suf = a[n];
cur = a[n], j = n;
for (int i = n - 1; i >= 1; i--) {
suf += a[i];
while (abs(cur + a[j - 1] - (suf - cur - a[j - 1])) < abs(cur - (suf - cur)))
cur += a[--j];
s[i] = {cur, suf - cur};
if (s[i][0] > s[i][1]) swap(s[i][0], s[i][1]);
}
ll ans = 1e9 + 123;
for (int i = 2; i <= n - 2; i++)
ans = min(ans, max(p[i][1], s[i + 1][1]) - min(p[i][0], s[i + 1][0]));
cout << ans;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <deque>
#include <queue>
#include <list>
#include <limits>
#include <set>
#include <map>
#include <functional>
#include <inttypes.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
using namespace std;
typedef long long ll;
#ifndef PRId64
#define PRId64 "lld"
#endif
#ifndef SCNd64
#define SCNd64 "lld"
#endif
#define SC sc()
#define PT pr()
#define FORi(i,b,e) for (int i = (b), _ = (e); i < _; ++i)
#define FORe(i,b,e) for (int i = (b), _ = (e); i <= _; ++i)
#define FORre(i,b,e) for (int i = (b), _ = (e); i >= _; --i)
static int sc_ret = 0;
struct sc
{
sc& operator()(char& v) { v = sc_ret = getchar(); return *this; }
sc& operator()(int& v) { sc_ret = scanf("%d", &v); return *this; }
sc& operator()(unsigned& v) { sc_ret = scanf("%u", &v); return *this; }
sc& operator()(double& v) { sc_ret = scanf("%lf", &v); return *this; }
sc& operator()(char* v) { sc_ret = scanf("%s", v); return *this; }
sc& operator()(string& v) { sc_ret = (bool)(cin >> v); return *this; }
sc& operator()(ll& v) { sc_ret = scanf("%" SCNd64, &v); return *this; }
sc& ch(char& v) { sc_ret = scanf(" %c", &v); return *this; }
sc& gets(char* v) { sc_ret = fgets(v, INT_MAX, stdin) != 0; v[strlen(v) - 1] = 0; return *this; }
operator bool() const { return sc_ret > 0; }
void read(int& v)
{
int x = 0, k = 1;
char c = getchar();
while (c < '0' || c > '9')
{
if (c == '-') k = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + (c - 48), c = getchar();
v = x * k;
}
};
struct pr
{
pr& ln() { putchar('\n'); return *this; }
pr& operator()(char v) { putchar(v); return *this; }
pr& operator()(int v) { printf("%d", v); return *this; }
pr& operator()(double v) { printf("%.2f", v); return *this; }
pr& operator()(const char* fmt, double v) { printf(fmt, v); return *this; }
pr& operator()(const char* v) { printf("%s", v);return *this; }
pr& operator()(string v) { printf("%s", v.c_str());return *this; }
pr& operator()(ll v) { printf("%" PRId64, v);return *this; }
void write(int v)
{
int cnt = 0; char c[15];
if (v == 0)
{
putchar('0');
return;
}
if (v < 0) putchar('-'), v = -v;
while (v) c[++cnt] = (v % 10) + 48, v /= 10;
while (cnt > 0) putchar(c[cnt--]);
}
template <typename T>
void ln(T* arr, int size)
{
if (size > 0)
{
(*this)(arr[0]);
for (int i = 1; i < size; ++i)
{
putchar(' ');
(*this)(arr[i]);
}
putchar('\n');
}
}
template <typename T>
void muln(T* arr, int size)
{
for (int i = 0; i < size; ++i)
{
(*this)(arr[i]);
putchar('\n');
}
}
};
const int inf = 0x3f3f3f3f;
const int mod = 1000000007;
const int maxn = 200000 + 10;
const int maxm = 100000 + 10;
ll a[maxn];
int main()
{
int n, t, k;
SC(n);
FORe(i, 1, n)
{
int v;
SC.read(v);
a[i] = v + a[i - 1];
}
int l = 1, r = 3; ll ret = a[n];
FORi(i, 2, n - 1)
{
for (; l < i - 1; ++l)
{
if (min(a[l], a[i] - a[l]) >= min(a[l + 1], a[i] - a[l + 1]))
break;
}
for (; r < n - 1; ++r)
{
if (min(a[r] - a[i], a[n] - a[r]) >= min(a[r + 1] - a[i], a[n] - a[r + 1]))
break;
}
ret = min(ret, max(max(a[r] - a[i], a[n] - a[r]), max(a[l], a[i] - a[l]))
- min(min(a[l], a[i] - a[l]), min(a[r] - a[i], a[n] - a[r])));
}
PT(ret);
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <cmath>
#include <iomanip>
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
using namespace std;
using lint = int64_t;
int main() {
const int INF = 1000000000;
int N, T;
cin >> N >> T;
vector<int> A(N), B(N);
rep(i, N) cin >> A[i] >> B[i];
vector<vector<int>> dp0(N + 1, vector<int>(T + 1, -INF)), dp1(N + 1, vector<int>(T + 1, -INF));
dp0[0][0] = 0;
dp1[N][0] = 0;
rep(i, N) rep(j, T + 1) {
dp0[i + 1][j] = max(dp0[i + 1][j], dp0[i][j]);
if (j + A[i] <= T) dp0[i + 1][j + A[i]] = max(dp0[i + 1][j + A[i]], dp0[i][j] + B[i]);
}
for (int i = N; i > 0; --i) rep(j, T + 1) {
dp1[i - 1][j] = max(dp1[i - 1][j], dp1[i][j]);
if (j + A[i - 1] <= T) dp1[i - 1][j + A[i - 1]] = max(dp1[i - 1][j + A[i - 1]], dp1[i][j] + B[i - 1]);
}
rep(i, N + 1) rep(j, T) {
dp0[i][j + 1] = max(dp0[i][j], dp0[i][j + 1]);
dp1[i][j + 1] = max(dp1[i][j], dp1[i][j + 1]);
}
int ans = 0;
rep(i, N) {
int res = 0;
rep(j, T) res = max(res, dp0[i][j] + dp1[i + 1][T - 1 - j]);
ans = max(ans, res + B[i]);
}
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (int i = (a); i <= (b); ++ i)
#define rrp(i,a,b) for (int i = (a); i >= (b); -- i)
#define gc() getchar()
#define fir first
#define sec second
typedef pair<int,int> pii;
typedef long double db;
typedef long long ll;
template <typename tp>
inline void read(tp& x) {
x = 0; char tmp; bool key = 0;
for (tmp = gc(); !isdigit(tmp); tmp = gc())
key = (tmp == '-');
for (; isdigit(tmp); tmp = gc())
x = (x << 3) + (x << 1) + (tmp ^ '0');
if (key) x = -x;
}
template <typename tp>
inline void ckmn(tp& x,tp y) {
x = x < y ? x : y;
}
template <typename tp>
inline void ckmx(tp& x,tp y) {
x = x < y ? y : x;
}
const int N = 510, MAX = 10000;
int isp[MAX + 10], pri[MAX], pcnt;
void prework() {
rep (i, 2, MAX) {
if (!isp[i]) pri[++pcnt] = i;
for (int j = 1; pri[j] * i <= MAX; ++ j) {
isp[pri[j] * i] = 1;
if (i % pri[j] == 0) break;
}
}
}
ll mat[N][N];
int n, arr[2][N];
set<ll> st;
ll lcm(ll x,ll y) {
return x / __gcd(x, y) * y;
}
int main() {
prework();
read(n);
if (n == 2) {
puts("4 7");
puts("23 10");
return 0;
}
int p = 0;
rep (i, 1, n) arr[0][i] = pri[++ p];
rrp (i, n, 1) arr[1][i] = pri[++ p];
int tmp = (n+1) / 2;
rep (i, 1, n) rep (j, 1, n) if ((i+j) % 2 == 0) {
int vx = i + j, vy = i - j;
vx /= 2;
vy /= 2;
vy += tmp;
mat[i][j] = 1ll * arr[0][vx] * arr[1][vy];
}
rep (i, 1, n) rep (j, 1, n) if ((i+j)&1) {
mat[i][j] = 1;
if (i > 1) mat[i][j] = lcm(mat[i][j], mat[i-1][j]);
if (i < n) mat[i][j] = lcm(mat[i][j], mat[i+1][j]);
if (j > 1) mat[i][j] = lcm(mat[i][j], mat[i][j-1]);
if (j < n) mat[i][j] = lcm(mat[i][j], mat[i][j+1]);
mat[i][j] ++;
}
// (i-j, i+j)
// rep (i, 1, n) rep (j, 1, n) {
// assert(!st.count(mat[i][j]));
// assert(mat[i][j] <= (ll)1e15);
// st.insert(mat[i][j]);
// }
rep (i, 1, n) {
rep (j, 1, n) printf("%lld ", mat[i][j]);
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using vc = vector<char>;
using pll = pair<ll, ll>;
template<class T> void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T> void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U> bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U> bool isin(T el, U container) { return find(all(container), el) != container.end(); }
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<class T> bool even(T n) { return ! (n & 1); }
template<class T> bool odd(T n) { return n & 1; }
template<class T> ll rup(T a, T b) { return a % b ? a / b + 1 : a / b; }
template<class T> ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T> ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll intpow(ll a, ll n, ll _mod=numeric_limits<ll>::max()) { ll p=1; while (n) { if (n&1) p=p*a%_mod; a=a*a%_mod; n>>=1; } return p; }
ll modc(ll a, char op, ll b, ll _mod=mod) { a %= _mod; b %= _mod; ll res = 1; switch(op) {
case '+': res = (a + b) % _mod; break;
case '-': res = (a - b) % _mod; break;
case '*': res = a * b % _mod; break;
case '/': res = modc(a, '*', modc(b, '^', _mod-2, _mod), _mod); break;
case '^': res = intpow(a, b, _mod); break;
case 'P': rep(i, a-b+1, a+1) res = modc(res, '*', i, _mod); break;
case 'C': res = modc(modc(a, 'P', b, _mod), '/', modc(b, 'P', b, _mod)); break; } if (res < 0) res += _mod; return res; }
int main()
{
ll H, W, N;
cin >> H >> W >> N;
ll bigger = max(H, W);
cout << rup(N, bigger) << endl;
}
| #include<stdio.h>
int main(){
int h, w, n, ans;
scanf("%d", &h);
scanf("%d", &w);
scanf("%d", &n);
if(w>=h){
if(n%w == 0){
ans = n/w;
}else if(n%w != 0){
ans = n/w+1;
}
}else if(w<=h){
if(n%h == 0){
ans = n/h;
}else if(n%h != 0){
ans = n/h+1;
}
}
printf("%d", ans);
} | 1 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
string S;
cin>>S;
map<char, int> amap;
for(int i=0;i<S.size();++i) {
amap[S[i]]++;
}
char ans = 'A';
for(char a='a';a<='z';++a) {
if(amap[a]==0) {
ans = a;
break;
}
}
if(ans=='A') cout<<"None"<<endl;
else cout<<ans<<endl;
}
| #include<vector>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <iostream>
#include <algorithm>
#define INF 100000000000000
using namespace std;
typedef long long llong;
//int isalpha(char ch): ch がアルファベットなら true を返す
//int isdigit(char ch): ch が数字なら true を返す
//int islower(char ch): ch が小文字なら true を返す
//int isupper(char ch): ch が大文字なら true を返す
//int tolower(char ch): ch の小文字を返す
//int toupper(char ch): ch の大文字を返す
//string型
//size() 文字数を返す
//insert() （指定した場所に）文字・文字列を挿入する
//erase() （指定した場所の）文字・文字列を削除する
//clear() すべての文字を削除する
//substr() 文字列の（指定した）部分文字列を返す
//replace() （指定した）部分文字列を新しい文字列に置換する
//文字列の比較は、<=や==などを使え
//replace関数を使い、簡単に文字列を置換
//リバース関数：reverse(str.begin(), str.end());
int main(){
string S;
vector<char> Table(26, 0);
cin >> S;
for(int i=0; i<S.size(); i++){
Table[S[i]-'a'] = 1;
}
for(int i=0; i<Table.size(); i++){
if(Table[i]==0){
printf("%c\n", 'a'+i);
exit(0);
}
}
cout << "None\n";
return 0;
} | 1 |
#include<iostream>
using namespace std;
int main () {
int H, W, A, B;
cin >> H >> W >> A >> B;
int zo[] = {0, 1};
for (int i = 0; i < B; i ++) {
for (int j = 0; j < A; j ++) {
cout << zo[0];
}
for (int j = A; j < W; j ++) {
cout << zo[1];
}
cout << endl;
}
for (int i = B; i < H; i ++) {
for (int j = 0; j < A; j ++) {
cout << zo[1];
}
for (int j = A; j < W; j ++) {
cout << zo[0];
}
cout << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
// type alias
typedef long long LL;
typedef pair<int,int> II;
typedef tuple<int,int,int> III;
typedef vector<int> VI;
typedef vector<string> VS;
typedef unordered_map<int,int> MAPII;
typedef unordered_set<int> SETI;
template<class T> using VV=vector<vector<T>>;
// minmax
template<class T> inline T SMIN(T& a, const T b) { return a=(a>b)?b:a; }
template<class T> inline T SMAX(T& a, const T b) { return a=(a<b)?b:a; }
// repetition
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) for(int i=0;i<=(n);++i)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define FORR(x,arr) for(auto& x:arr)
#define SZ(a) int((a).size())
// collection
#define ALL(c) (c).begin(),(c).end()
// DP
#define MINUS(dp) memset(dp, -1, sizeof(dp))
#define ZERO(dp) memset(dp, 0, sizeof(dp))
// stdout
#define println(args...) fprintf(stdout, ##args),putchar('\n');
// debug cerr
template<class Iter> void __kumaerrc(Iter begin, Iter end) { for(; begin!=end; ++begin) { cerr<<*begin<<','; } cerr<<endl; }
void __kumaerr(istream_iterator<string> it) { (void)it; cerr<<endl; }
template<typename T, typename... Args> void __kumaerr(istream_iterator<string> it, T a, Args... args) { cerr<<*it<<"="<<a<<", ",__kumaerr(++it, args...); }
template<typename S, typename T> std::ostream& operator<<(std::ostream& _os, const std::pair<S,T>& _p) { return _os<<"{"<<_p.first<<','<<_p.second<<"}"; }
#define __KUMATRACE__ true
#ifdef __KUMATRACE__
#define dump(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); __kumaerr(_it, args); }
#define dumpc(ar) { cerr<<#ar<<": "; FORR(x,(ar)) { cerr << x << ','; } cerr << endl; }
#define dumpC(beg,end) { cerr<<"~"<<#end<<": "; __kumaerrc(beg,end); }
#else
#define dump(args...)
#define dumpc(ar)
#define dumpC(beg,end)
#endif
// $ cp-batch 01Matrix | diff 01Matrix.out -
// $ g++ -std=c++14 -Wall -O2 -D_GLIBCXX_DEBUG -fsanitize=address 01Matrix.cpp && ./a.out
/*
8/3/2020
21:24-
*/
int H,W,A,B;
void solve() {
REP(_,B) {
REP(j,W) cout<<char('0'+(j<A));
cout<<endl;
}
REP(_,H-B) {
REP(j,W) cout<<char('0'+(j>=A));
cout<<endl;
}
}
bool ith(int mask, int i) { return (mask>>i)&1; }
void test() {
set<II> ps;
REP(mask, 1<<25) {
VV<int> G(5,VI(5,0));
REP(i,25) if(ith(mask,i)) {
G[i/5][i%5]=1;
}
set<int> r,c;
REP(i,5) {
int cnt[2]={};
REP(j,5) cnt[G[i][j]]++;
r.emplace(min(cnt[0],cnt[1]));
}
REP(j,5) {
int cnt[2]={};
REP(i,5) cnt[G[i][j]]++;
c.emplace(min(cnt[0],cnt[1]));
}
if(SZ(r)==1&&SZ(c)==1) {
if(*r.begin()==2&&*c.begin()==1) {
REP(i,5) dumpc(G[i]);
}
ps.emplace(*r.begin(), *c.begin());
}
}
dumpc(ps);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout<<setprecision(12)<<fixed;
cin>>H>>W>>A>>B;
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
ll n;cin>>n;
int ans=1e9;
for(int i=1;i<=sqrt(n);i++){
if(n%i!=0)continue;
ll j=n/i;
string I=to_string(i),J=to_string(j);
int a=I.size(),b=J.size();
int f=max(a,b);
ans=min(ans,f);
}
cout<<ans<<endl;
} | #include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (int)n; ++i)
#define rrep(i, j, n) for (int i = (int)n - 1; j <= i; --i)
int main() {
ll n;
cin >> n;
ll m = (ll)sqrt((double)n);
auto d = [](ll x) {
ll res = 0;
while (x) {
x /= 10;
res++;
}
return res;
};
rrep(i, 1, m + 1) {
if (n % i == 0) {
cout << max(d(i), d(n / i)) << '\n';
return 0;
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using i64 = int_fast64_t;
#define rep(i, N) for(int (i) = 0; (i) < (N); (i)++)
#define all(v) (v).begin(), (v).end()
#define eb emplace_back
#define Cout(s) cout << s << endl
string Yes(bool b) {if(b){return "Yes";} else {return "No";}}
string YES(bool b) {if(b){return "YES";} else {return "NO";}}
int main(){
string S;
cin >> S;
if(S.size() == 3) reverse(all(S));
Cout(S);
}
| #include <iostream>
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
#define int long long
using namespace std;
signed main() {
string S;
cin>>S;
if(S.size()==2){
cout<<S<<endl;
}
else{
cout<<S[2]<<S[1]<<S[0]<<endl;
}
} | 1 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>
#include <cstring>
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define repn(i,n,m) for(int i=n;i<m;i++)
#define repn1(i,n,m) for(int i=n;i<=m;i++)
using namespace std;
int main(){
int dp[100] = {0};
int n;
dp[1] = 1;
dp[2] = 2;
dp[3] = 4;
repn1(i, 4, 30) dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
while(cin >> n, n){
cout << dp[n] / 3650 + (dp[n]%3650==0 ? 0 : 1) << endl;
}
return 0;
} | #include <iostream>
#include <cstdio>
using namespace std;
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
int table[11][11] = {};
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> table[i][j];
}
}
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
sum += table[i][j];
}
table[i][n] = sum;
}
for (int i = 0; i <= n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
sum += table[j][i];
}
table[n][i] = sum;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
printf("%5d",table[i][j]);
}
printf("\n");
}
}
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n, m;
int p[1000];
cin >> n >> m;
while (n != 0 || m != 0) {
for (int i = 0; i < n; i++)
cin >> p[i];
sort(p, p + n, greater<int>());
int s = 0;
for (int i = 0; i < n; i++) {
if (i % m != m - 1)
s += p[i];
}
cout << s << endl;
cin >> n >> m;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pq priority_queue
#define debug(x) cerr << #x << ": " << x << endl;
#define line() cerr << "---------------" << endl;
int main() {
int n, m;
while (cin >> n >> m) {
if (n == 0 && m == 0) break;
vector<int> v(n);
int sum = 0;
for (int &x : v) {
cin >> x;
sum += x;
}
sort(v.begin(), v.end(), greater<int>());
for (int i = m-1; i < v.size(); i+=m) {
sum -= v[i];
}
cout << sum << endl;
}
return 0;
}
| 1 |
//15
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
double l[12];
double ls[13]={};
for(;;){
for(int i=0;i<12;i++){
(cin>>l[i]).ignore();
if(!cin)return 0;
ls[i+1]=ls[i]+l[i];
}
cout<<lower_bound(ls,ls+11,l[10]*ls[10]/(l[10]+l[11]))-ls<<endl;
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <string>
using namespace std;
#define rep2(x,from,to) for(int x = (from); x < (to); ++(x))
#define rep(x,to) rep2(x,0,to)
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int b[14][14];
void dfs(int y, int x) {
if(!b[y][x]) return;
b[y][x] = 0;
rep(i,4) {
dfs(y+dy[i], x+dx[i]);
}
}
int main() {
string s;
while(cin >> s) {
rep(i,14) {
b[0][i] = b[i][0] = 0;
b[13][i] = b[i][13] = 0;
}
rep(i,12) {
b[1][i+1] = s[i] - '0';
}
rep2(i,2,13) {
cin >> s;
rep(j,12) {
b[i][j+1] = s[j] - '0';
}
}
int cnt = 0;
rep(i,14) {
rep(j,14) {
if(b[i][j]) {
dfs(i,j);
cnt++;
}
}
}
cout << cnt << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <vector>
#include <math.h>
using namespace std;
int main(){
long long x,y;
cin>>x>>y;
if(x*y < 0) cout<<abs(abs(x) - abs(y))+1<<endl;
else if(x*y == 0){
if(x<y) cout<<y-x<<endl;
else cout<<x-y+1<<endl;
}
else {
if(x<y) cout<<y-x<<endl;
else
cout<<x-y+2<<endl;
}
return 0;
}
| #include<iostream>
#include<iomanip>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<numeric>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60) //1LL<<63でオーバーフロー
#define inf (1<<29) //1<<29でオーバーフロー
int main(int argc,char* argv[]){
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
int n;
ll y;
cin >> n >> y;
for(ll i=0;10000*i<=y;i++){
ll x=y-10000*i;
for(ll j=0;5000*j<=x;j++){
ll k=(x-5000*j)/1000;
if(i+j+k==n){
cout << i << " " << j << " " << k << endl;
return 0;
}
}
}
cout << -1 << " " << -1 << " " << -1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
int main() {
int N; cin >> N;
int x, ans;
for (int i = 9; i >= 1; i--) {
x = i * 111;
if (N <= x) ans = x;
}
cout << ans << endl;
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repi(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define repdi(i,a,b) for(ll i=(a)-1;i>=(b);--i)
#define repd(i,a) repdi(i,a,0)
#define itr(it,a) for( auto it = (a).begin(); it != (a).end(); ++it )
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll INF = 1ll<<60;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class S, class T>
std::ostream& operator<< ( std::ostream& out, const std::pair<S,T>& a )
{ std::cout << '(' << a.first << ", " << a.second << ')'; return out; }
template<class T>
std::ostream &operator<< ( std::ostream& out, const std::vector<T>& a )
{ std::cout << '['; rep( i, a.size() ){ std::cout << a[i]; if( i != a.size()-1 ) std::cout << ", "; } std::cout << ']'; return out; }
ll N;
int main()
{
std::cin >> N;
std::cout << N/3 << std::endl;
return 0;
} | 0 |
#include <iostream>
#include <stdio.h>
#include <vector>
#include <math.h>
using namespace std;
int main(void){
int N; cin >> N;
int i = 0;
int answer = 0;
if (N / 100 > (N - N / 100 * 100) / 10) answer = N / 100;
else if (N / 100 < (N - N / 100 * 100) / 10) answer = N / 100 + 1;
else if ((N - N / 100 * 100) / 10 >= N % 10) answer = N / 100;
else answer = N / 100 + 1;
cout << answer << answer << answer << endl;
} | /*
ID: anonymo14
TASK: wormhole
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {//227
int i;
cin>>i;
for(;i<=999;i++) {
if(i%10==(i%100)/10&&i%10==i/100){
cout<<i;
return;
}
}
}
int main() {
////// FILE BASED IO////
//freopen("wormhole.in", "r", stdin);
//freopen("wormhole.out", "w", stdout);
///////////////
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
//cin>>t;
REP(i,1,t) {
solve(i);
}
return 0;
}
| 1 |
#include<stdio.h>
main(){
int i,d,s;
while(scanf("%d",&d)!=EOF){
s=0;
for(i=0;i<600/d;i++){
s+=(d*((d*i)*(d*i)));
}
printf("%d\n",s);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
double r;
cin>>r;
cout<<2*r*M_PI;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> ii;
const int N = 500005;
int n,m;
map<ii, int> id;
vector<ii> G[N];
int ct = 1;
priority_queue<ii, vector<ii>, greater<ii> > pq;
int dist[N];
int main(){
scanf("%d%d",&n,&m);
ct = n+1;
for (int i = 0; i < m; i++){
int p,q,c;
scanf("%d%d%d",&p,&q,&c);
int a,b;
if (id.count({p,c})) a = id[ii(p,c)];
else{
a = id[ii(p,c)] = ct++;
G[a].push_back({p,1});
G[p].push_back({a,1});
}
if (id.count({q,c})) b = id[ii(q,c)];
else{
b = id[ii(q,c)] = ct++;
G[b].push_back({q,1});
G[q].push_back({b,1});
}
G[a].push_back({b,0});
G[b].push_back({a,0});
}
memset(dist,-1,sizeof(dist));
dist[1] = 0;
pq.push({0,1});
while (pq.size()){
int d, u;
tie(d,u) = pq.top(); pq.pop();
if (d > dist[u]) continue;
for (auto v : G[u]){
int nd = d + v.second;
if (dist[v.first] == -1 || dist[v.first] > nd){
dist[v.first] = nd;
pq.push({nd,v.first});
}
}
}
if (dist[n] == -1) printf("-1\n");
else printf("%d",dist[n]/2);
}
| // #pragma GCC optimize("O3")
// #pragma GCC target("avx2")
#include <bits/stdc++.h>
using namespace std;using ll=long long;using uint=unsigned int;using pii=pair<int,int>;using pll=pair<ll,ll>;using ull = unsigned long long;using ld=long double;template<typename T>void _(const char*s,T h){cerr<<s<<" = "<<h<<"\n";}template<typename T,typename...Ts>void _(const char*s,T h,Ts...t){int b=0;while(((b+=*s=='(')-=*s==')')!=0||*s!=',')cerr<<*s++;cerr<<" = "<<h<<",";_(s+1,t...);}// break continue pop_back 998244353
// #define int ll
// #define pii pll
#define f first
#define s second
#define pb emplace_back
#define forn(i,n) for(int i=0;i<(n);++i)
#define sz(a)((int)(a).size())
#define sqr(x) ((x)*(x))
struct init{init(){cin.tie(0);iostream::sync_with_stdio(0);cout<<fixed<<setprecision(10);cerr<<fixed<<setprecision(5);}~init(){
#ifdef LOCAL
#define dbg(...) _(#__VA_ARGS__,__VA_ARGS__)
cerr<<"Time elapsed: "<<(double)clock()/CLOCKS_PER_SEC<<"s.\n";
#else
#define dbg(...)
#endif
}}init;template<typename T,typename U>void upx(T&x,U y){if(x<y)x=y;}template<typename T,typename U>void upn(T&x,U y){if(x>y)x=y;}mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());const int D=4,dx[]={+1,0,-1,0},dy[]={0,+1,0,-1};
const int N=1e5+5,OO=1e9;
vector<pii> gg[N];
vector<int> v[N];
vector<int> num[N];
int xx[N*4],zz[N*4],dist[N*4];
vector<vector<int>> g[N];
int u[N];
int q[N*8];
int32_t main(){
int n,m;
cin>>n>>m;
forn(i,m){
int x,y,z;
cin>>x>>y>>z;
gg[x].pb(y,z);
gg[y].pb(x,z);
v[x].pb(z);
v[y].pb(z);
}
int cnt=0;
for(int i=1;i<=n;++i){
sort(v[i].begin(), v[i].end());
v[i].resize(unique(v[i].begin(), v[i].end())-v[i].begin());
g[i].resize(sz(v[i]));
num[i].resize(sz(v[i]));
forn(j,sz(v[i])){
xx[cnt]=i;zz[cnt]=j;
dist[cnt]=OO;
num[i][j]=cnt++;
}
for(pii p:gg[i]){
int to=p.f,z=p.s;
z=lower_bound(v[i].begin(), v[i].end(),z)-v[i].begin();
g[i][z].pb(to);
}
}
int l=N*3,r=N*3;
forn(i,sz(v[1])){
dist[num[1][i]]=1;
q[r++]=num[1][i];
}
u[1]=1;
while(l<r){
int nu=q[l++];
int x=xx[nu],pz=zz[nu];
int z=v[x][pz];
if(!u[x]){
u[x]=1;
forn(i,sz(v[x])){
int nt=num[x][i];
if(dist[nt]>dist[nu]+1){
dist[nt]=dist[nu]+1;
q[r++]=nt;
}
}
}
for(int to:g[x][pz]){
int pzt=lower_bound(v[to].begin(), v[to].end(),z)-v[to].begin();
int nt=num[to][pzt];
if(dist[nt]>dist[nu]){
dist[nt]=dist[nu];
q[--l]=nt;
}
}
}
int ans=OO;
forn(i,sz(v[n]))upn(ans,dist[num[n][i]]);
if(ans==OO)ans=-1;
cout<<ans<<'\n';
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#define int long long
#define pb push_back
#define x first
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
/// find_by_order()
/// order_of_key()
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
const int INF = 1e9, MOD = 1e9 + 7; /// think
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
inline bool inside (int x, int y, int n, int m) {
return 0 <= x && 0 <= y && x < n && y < m;
}
template<class T> bool umin (T &a, T b) {return a > b ? (a = b, true) : false; }
template<class T> bool umax (T &a, T b) {return a < b ? (a = b, true) : false; }
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector <int> a(n);
vector <vector<pii> > b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i].resize(a[i]);
for (auto &j : b[i]) {
cin >> j.y >> j.x;
--j.y;
}
}
int ans = 0;
for (int i = 1; i < (1 << n); i++) {
int res = 0;
vector <int> used(n);
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
++res;
used[j] = 1;
}
}
if (ans >= res) continue;
bool ok = true;
for (int j = 0; j < n; j++) {
if (!used[j]) continue;
for (auto &k : b[j]) {
if (k.x) {
if (!used[k.y]) {
ok = false;
}
}
else {
if (used[k.y]) {
ok = false;
}
}
}
}
if (ok) ans = res;
}
cout << ans << '\n';
}
| #define rep(i, n) for (int i = 0; i < (n); i++)
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
// MAX int 2,147,483,647 -> 10桁
// MAX ll 9,223,372,036,854,775,807 -> 19桁
// MAX O(n) 10^8 -> 8回
// double pi = M_PI or acos(-1)
// printf("%.10f\n", ans);
int g[15][15];
int main() {
int n;
cin >> n;
rep(i, n) rep(j, n) g[i][j] = -1;
rep(i, n) {
int m;
cin >> m;
rep(j, m) {
int a, x;
cin >> a >> x;
--a;
g[i][a] = x;
}
}
int ans = 0;
rep(i, 1 << n) {
vector<int> d(n);
rep(j, n) if(i >> j & 1) {
d[j] = 1;
}
bool ok = true;
rep(j, n) {
if(d[j]) {
rep(k, n) {
if (g[j][k] == -1) continue;
if (g[j][k] != d[k]) ok = false;
}
}
}
if (ok) ans = max(ans, __builtin_popcount(i));
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = s; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n,q; string s;
cin >> n >> q >> s;
vector<int> a(n+1,0);
rep(i,1,n+1) {
if (s.substr(i-1,2) == "AC") {
a[i]++;
}
a[i] += a[i-1];
}
rep(i,0,q) {
int l,r;
cin >> l >> r;
int ans = a[r] - a[l];
if (a[l] != a[l-1]) ans++;
if (a[r] != a[r-1]) ans--;
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using pp=pair<int,int>;
int main() {
int N, doubt=0, M=0;
cin >> N;
vector<vector<pp>> V(N, vector<pp>(0));
int A, p, q;
for (int i=0; i<N; i++) {
cin >> A;
for (int j=0; j<A; j++) {
cin >> p >> q;
V[i].push_back(pp(p,q));
}
}
for (int b=0; b<(1<<N); b++) {
bitset<15> s(b);
vector<int> W(N);
doubt=0;
for (int i=0; i<N; i++) {
W[i]=s.test(i);
//cout << W[i] << endl;
}
for (int i=0; i<N; i++) {
if (s.test(i)) {
for (int j=0; j<(int)V[i].size(); j++) {
int x=V[i][j].first, y=V[i][j].second;
if (W[x-1]!=y) {
doubt=1;
break;
}
}
if (doubt==1) {break;}
}
}
if (doubt==0) {
int rr=0;
for (int i=0; i<N; i++) {
rr+=s.test(i);
}
M=max(M, rr);
//cout << M << endl;
}
}
cout << M << endl;
} | 0 |
#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<ll,ll> P;
#define rep(i,n) for(int i = 0; i < int(n); i++)
using namespace std;
template<class T> inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
constexpr ll mod = 1e9 + 7;
struct UnionFind {
public:
vector <ll> par; //
vector <ll> siz; //
UnionFind() {}
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
int main() {
ll n;
cin >> n;
vector<int> ans;
for (int i = 0; i < 60; i++) {
ll m = n % (1LL << (i+1));
if (m) {
ans.push_back(1);
ll sub = 1LL << i;
if (i % 2 == 1) {
sub *= -1;
}
n -= sub;
}
else ans.push_back(0);
if (n == 0) break;
}
reverse(ans.begin(), ans.end());
for (auto a : ans) {
cout << a;
}
cout << endl;
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i=0;i < (int)(n);i++)
int main(){
int n;
cin >> n;
string s = "";
while(n != 0){
int r = n%2;
if (r < 0) r +=2;
n = (n-r)/(-2);
s += (char)('0' + r);
}
reverse(s.begin(),s.end());
if (s == "") s = "0";
cout << s << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
ll a,b,i,cnt=0;
scanf("%lld %lld", &a, &b);
while(a<=b){
string s;
s = to_string(a);
if(s[0]==s[4] && s[1]==s[3]){
cnt++;
}
a++;
}
printf("%lld\n", cnt);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int a12 = a/1000;
int a21 = a12/10 + a12%10*10;
int b12 = b/1000;
int b21 = b12/10 + b12%10*10;
// 上２ケタがa12でaより小さいのを弾く
int count_less_than_a = 0;
for (int i = 0; i <= 9; i++) {
if (a12*1000 + i*100 + a21 < a){
count_less_than_a++;
}
else {
break;
}
}
// 上２ケタがb12でbより大きいのを弾く
int count_more_than_b = 0;
for (int i = 9; i >= 0; i--) {
if (b12*1000 + i*100 + b21 > b){
count_more_than_b++;
}
else {
break;
}
}
int result = (b12 - a12 +1) * 10
- count_less_than_a - count_more_than_b;
cout << result << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define ll long long
#define P pair<ll,ll>
#define all(v) (v).begin(),(v).end()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1.0);
int main(void)
{
ll n; cin>>n;
ll ans=1;
for(ll i=1;i<=n;i++){
if(i*i<=n) ans=max(ans,i*i);
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repI(i, d, n) for (int i = (d); i < (n); ++i)
#define reps1(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using M = map<int, int>;
using Ml = map<ll, ll>;
ll const INF = 1ll<<61;
double pi = 3.141592653589793238;
int main() {
ll n;
cin >> n;
cout << ll(sqrt(n)) * ll(sqrt(n)) << endl;
return 0;
}
| 1 |
#include <iostream>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;
bool furui[10010];
vector<int> prime;
vector<int> twin;
void mkprime() {
for(int i = 0; i < 10010; i++) furui[i] = true;
furui[0] = furui[1] = false;
for(int i = 0; i < 10010; i++) {
if(furui[i]) {
prime.push_back(i);
for(int j = i * 2; j < 10010; j += i) {
furui[j] = false;
}
}
}
for(int i = 0; i < prime.size() - 1; i++) {
if(prime[i + 1] - prime[i] == 2)
twin.push_back(prime[i + 1]);
}
sort(twin.begin(), twin.end());
}
int main() {
int n;
mkprime();
while(cin >> n, n) {
vector<int>::iterator iter;
iter = upper_bound(twin.begin(), twin.end(), n);
cout << *(iter-1) - 2 << " " << *(iter-1) << endl;
}
} | #include <iostream>
#include <cmath>
using namespace std;
bool isprime(int n);
int main(void){
int n;
while(1){
cin>>n;
if(n==0)break;
for(int j=n;j>0;j--){
if(isprime(j) && isprime(j-2)){
cout<<j-2<<" "<<j<<endl;
break;
}
}
}
return 0;
}
bool isprime(int n){
for(int i=2;i<min((int)sqrt(n)+1,n);i++){
if(n%i==0){
return false;
}
}
return true;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;
void solve() {
int n;
cin >> n;
vector<ll> a(n);
for (int i=0; i<n; ++i) {
cin >> a.at(i);
}
ll sumO = 0, sumE = 0;
for (int i=0; i<n; ++i) {
if (i % 2 == 0) sumO += a.at(i);
else sumE += a.at(i);
}
if (n % 2 == 0) {
ll res = sumE;
ll curO = 0, curE = 0;
for (int i=0; i<n; ++i) {
if (i % 2 == 0) {
curO += a.at(i);
} else {
curE += a.at(i);
chmax(res, sumE + curO - curE);
}
}
cout << res << '\n';
} else {
ll res = sumE;
ll curO = 0, curE = 0;
vector<ll> diff(n);
for (int i=0; i<n; ++i) {
if (i % 2 == 0) {
curO += a.at(i);
} else {
curE += a.at(i);
chmax(diff.at(i), curO - curE);
if (i > 1) chmax(diff.at(i), diff.at(i-2));
}
}
chmax(res, sumE + diff.at(n-1));
curO = curE = 0;
ll maxi = 0;
for (int i=n-1; i>=0; --i) {
if (i % 2 == 0) {
curO += a.at(i);
} else {
curE += a.at(i);
chmax(maxi, curO - curE);
if (i == 1) chmax(res, sumE + maxi);
else chmax(res, sumE + diff.at(i-2) + maxi);
}
}
cout << res << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
| #include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9+7;
const long long LINF = 1e18;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) for(int i=0;i<(n);++i)
#define REPR(i,n) for(int i=n;i>=0;i--)
#define FOREACH(x,a) for(auto& (x) : (a) )
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template<typename T>
void print(const vector<T> &x) {
int n = x.size();
rep(i,n) {
cout << x[i];
if (i!=n-1) cout<<" ";
else cout << endl;
}
}
template<typename T>
void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i,n) {
rep(j,x[i].size()) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
template<typename T>
void print(const vector<T> &x, int n) {
rep(i,n) {
cout << x[i];
if (i!=n-1) cout<<" ";
else cout << endl;
}
}
template<typename T>
void print(const vector<vector<T>> &x, int n, int m) {
rep(i,n) {
rep(j,m) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
void input_init() {
cin.tie(0); ios::sync_with_stdio(false);
}
ll sol_even(int n, const vector<ll> &a) {
ll dp[200200][2];
rep(i,200200) rep(j,2) dp[i][j] = -LINF;
dp[0][0] = a[0];
dp[1][1] = a[1];
rep(i,n) {
if (i+2 < n) chmax(dp[i+2][0], dp[i][0]+a[i+2]);
if (i+3 < n) chmax(dp[i+3][1], dp[i][0]+a[i+3]);
if (i+2 < n) chmax(dp[i+2][1], dp[i][1]+a[i+2]);
}
return max(dp[n-2][0], dp[n-1][1]);
}
ll dp[200200][3][2];
ll sol_odd(int n, const vector<ll> &a) {
rep(i,200200) rep(j,3) rep(k,2) dp[i][j][k] = -LINF;
dp[0][0][0] = a[0];
dp[1][1][0] = a[1];
dp[2][2][0] = a[2];
rep(i,n) {
if (i+2 < n && i+2 != n-1) chmax(dp[i+2][0][0], dp[i][0][0]+a[i+2]);
if (i+3 < n) chmax(dp[i+3][1][0], dp[i][0][0]+a[i+3]);
if (i+4 < n) chmax(dp[i+4][0][1], dp[i][0][0]+a[i+4]);
if (i+3 < n) chmax(dp[i+3][2][0], dp[i][1][0]+a[i+3]);
if (i+2 < n) chmax(dp[i+2][1][0], dp[i][1][0]+a[i+2]);
if (i+2 < n) chmax(dp[i+2][2][0], dp[i][2][0]+a[i+2]);
if (i+2 < n) chmax(dp[i+2][0][1], dp[i][0][1]+a[i+2]);
}
return max({dp[n-3][0][0], dp[n-2][1][0], dp[n-1][2][0], dp[n-1][0][1]});
}
int main(int argc, char const *argv[]) {
int n; cin>>n;
vector<ll> a(n);
rep(i,n) cin>>a[i];
if (n%2) cout << sol_odd(n,a) << '\n';
else cout << sol_even(n,a) << '\n';
return 0;
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
typedef vector<int> IntVector;
IntVector a(n, 0);
for (int i = 0; i < n; ++i)
cin >> skipws >> a[i];
IntVector::const_reverse_iterator ritEnd = a.rend();
for (IntVector::const_reverse_iterator rit = a.rbegin(); rit != ritEnd; ++rit)
{
cout << *rit;
if (rit == ritEnd - 1)
cout << endl;
else
cout << " ";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n;
int a[100];
cin>>n;
for(int i=0; i<n; i++) cin>>a[i];
for( int i=0; i< n-1-i; i++) swap(a[i],a[n-1-i]);
for( int i=0; i<n; i++){
if(i) cout<<" ";
cout<<a[i];
}
cout<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <array>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for(UL i = 0; i < (n); i++)
struct Problem {
UL S[2001][2001] = {};
UL J1[2001][2001] = {};
UL J2[2001][2001] = {};
void Query() {
UL y1, y2, x1, x2; cin >> y1 >> x1 >> y2>> x2;
y1--; x1--;
UL mass = S[x2][y2] + S[x1][y1] - S[x1][y2] - S[x2][y1];
UL J1s = J1[x2][y2] + J1[x1 + 1][y1] - J1[x1 + 1][y2] - J1[x2][y1];
UL J2s = J2[x2][y2] + J2[x1][y1 + 1] - J2[x1][y2] - J2[x2][y1 + 1];
cout << (mass - J1s - J2s) << endl;
}
void Solve() {
UL H, W; cin >> H >> W;
UL Q; cin >> Q;
rep(y, H) rep(x, W) {
char c; cin >> c;
S[x + 1][y + 1] = (c - '0');
}
rep(y, H) rep(x, W) if (S[x][y + 1] && S[x + 1][y + 1]) J1[x + 1][y + 1] = 1;
rep(y, H) rep(x, W) if (S[x + 1][y] && S[x + 1][y + 1]) J2[x + 1][y + 1] = 1;
rep(y, H) rep(x, W) S[x + 1][y + 1] += S[x][y + 1];
rep(y, H) rep(x, W) S[x + 1][y + 1] += S[x + 1][y];
rep(y, H) rep(x, W) J1[x + 1][y + 1] += J1[x][y + 1];
rep(y, H) rep(x, W) J1[x + 1][y + 1] += J1[x + 1][y];
rep(y, H) rep(x, W) J2[x + 1][y + 1] += J2[x][y + 1];
rep(y, H) rep(x, W) J2[x + 1][y + 1] += J2[x + 1][y];
rep(i, Q) Query();
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() {
cout << fixed << setprecision(10);
} | #include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
char s[2003][2003];
char l[2003][2003];
int pr[2003][2003];
int pl[2003][2003];
int pu[2003][2003];
int pd[2003][2003];
int c[2003][2003];
int p[2003];
int main()
{
int n, m, q;
cin >> n >> m >> q;
for(int i = 0; i < n; i++) for(int j = 0; j < m; j++){
cin >> s[i][j];
l[i][j] = '.';
}
for(int i = 0; i < n; i++) for(int j = 0; j < m; j++) if(s[i][j] == '1' && l[i][j] == '.'){
queue<P> que;
l[i][j] = 'c';
que.push(P(i, j));
while(que.size()){
int x = que.front().first, y = que.front().second;
que.pop();
for(int k = 0; k < 4; k++){
int xx = x + dx[k], yy = y + dy[k];
if(xx >= 0 && xx < n && yy >= 0 && yy < m && s[xx][yy] == '1' && l[xx][yy] == '.'){
if(k == 0) l[xx][yy] = 'u';
if(k == 1) l[xx][yy] = 'l';
if(k == 2) l[xx][yy] = 'd';
if(k == 3) l[xx][yy] = 'r';
que.push(P(xx, yy));
}
}
}
}
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
if(l[i][j] == 'u') pu[i][j]++;
if(l[i][j] == 'd') pd[i][j]++;
pu[i][j + 1] = pu[i][j];
pd[i][j + 1] = pd[i][j];
}
}
for(int j = 0; j < m; j++){
for(int i = 0; i < n; i++){
if(l[i][j] == 'r') pr[j][i]++;
if(l[i][j] == 'l') pl[j][i]++;
pr[j][i + 1] = pr[j][i];
pl[j][i + 1] = pl[j][i];
}
}
for(int i = n - 1; i >= 0; i--){
int k = 0;
for(int j = m - 1; j >= 0; j--){
if(l[i][j] == 'c') p[j]++;
k += p[j];
c[i][j] = k;
}
}
for(int e = 0; e < q; e++){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1--; y1--; x2--; y2--;
int ans = c[x1][y1] - c[x2 + 1][y1] - c[x1][y2 + 1] + c[x2 + 1][y2 + 1];
ans += pu[x1][y2] + pd[x2][y2] + pl[y1][x2] + pr[y2][x2];
if(y1 > 0) ans -= pu[x1][y1 - 1] + pd[x2][y1 - 1];
if(x1 > 0) ans -= pl[y1][x1 - 1] + pr[y2][x1 - 1];
cout << ans << endl;
}
} | 1 |
/**
* author: otera
**/
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<deque>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef long double ld;
const int inf=1e9+7;
const ll INF=1LL<<60 ;
const ll mod=1e9+7 ;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<int, int> P;
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
#define debug(x) cerr << #x << " = " << (x) << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
void solve() {
int n; cin >> n;
if(n == 1) {
cout << "Hello World" << endl;
} else {
int a, b; cin >> a >> b;
cout << a + b << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(10);
//int t; cin >> t; rep(i, t)solve();
solve();
return 0;
} | #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#define rep(i,n) for (int i = 0;i < (n);i++)
#define all(v) v.begin(),v.end()
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b , a % b);
}
ll mod(ll a){
return (a % 1000000007);
}
ll lcm(ll a,ll b){
return (a*b)/gcd(a,b);
}
int main(){
ll n; cin >> n; ll a,b; cin >> a >> b;
if(n==1) cout << "Hello World" << endl;
else cout << a+b << endl;
} | 1 |
#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
using namespace std;
void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
int partition(vector<int> &A, int p, int r) {
int x = A[r];
int i = p;
for (int j = p; j < r; j++) {
if (A[j] <= x) {
swap(A[i], A[j]);
i++;
}
}
swap(A[i], A[r]);
return i;
}
int main() {
int n = 0;
cin >> n;
vector<int> v;
v.resize(n);
{
vector<int>::iterator i = v.begin();
copy(istream_iterator<int>(cin), istream_iterator<int>(), i++);
}
int p = partition(v, 0, n-1);
for (int i = 0; i < n; i++) {
if (i == p) {
cout << "[" << v[i] << "] ";
}
else if (i == n - 1) {
cout << v[i] << "\n";
}
else {
cout << v[i] << " ";
}
}
return 0;
} | #include <stdio.h>
#define N 1000000
int n;
int S[N];
int partition(int n){
int x = S[n];
int i,p=0;
int tmp;
int j;
for(i = 0;i < n;i++){
//printf("%d\n",i);
if(S[i] <= x){
tmp = S[i];
S[i] = S[p];
S[p] = tmp;
p++;
}
/*
for(j=0;j<n+1;j++){
printf("%d ",S[j]);
}
printf("\n");
printf("p = %d\n",p);*/
}
tmp = S[p] ;
S[p] = S[n];
S[n] = tmp;
return p;
}
int main(){
scanf("%d",&n);
int i;
for(i=0;i<n;i++){
scanf("%d",&S[i]);
}
int m = partition(n-1);
for(i = 0;i< n;i++){
if(m == i){
printf("[%d] ",S[i]);
}
else if(i == n-1)printf("%d\n",S[i]);
else printf("%d ",S[i]);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main()
{
ll N; cin >> N;
vector<ll> A(N, 0);
map<ll, ll, greater<ll>> m;
for (int i = 0; i < N; ++i) {
cin >> A[i];
m[A[i]]++;
}
int cnt = 0;
ll a = 0;
ll b = 0;
for (auto i : m) {
if (i.second > 1) {
if (cnt == 0) {
a = i.first;
if (i.second > 3) {
b = i.first;
break;
}
cnt++;
}
else {
b = i.first;
break;
}
}
}
cout << a * b << endl;
}
| #include <bits/stdc++.h>
using namespace std;
template<class T> void ckmin(T &a, T b) { a = min(a, b); }
template<class T> void ckmax(T &a, T b) { a = max(a, b); }
#define pb push_back
#define mp make_pair
#define cotu cout
#define itn int
#define Red ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define F first
#define S second
#define sz(x) (int)x.size()
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int i = 0; i < n; ++i)
#define repr(i,n) for(int i = n - 1; i >= 0; --i)
#define Rep(i, a, n) for(int i = (a); i <=(n); ++i)
#define repst(i, n) for(auto it = n.begin(); it != n.end(); ++it)
#define Repr(i, a, n) for(int i = (n); i >= (a); --i)
#define sp(x) fixed << setprecision(x)
#define ordered_set tree<int , null_type,less<int >, rb_tree_tag,tree_order_statistics_node_update>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const int inf = int(1e9);
const int mod = inf + 7;
const int N = 1e6 + 555; // TL MB
const double PI = acos(-1.0);
void mul(ll &x, ll y){
x *= y;
if(x >= mod) x %= mod;
}
void add(ll &x, ll y){
x += y;
if(x >= mod) x -= mod;
if(x < 0) x += mod;
}
ll bp(ll a, ll n){
ll r = 1;
while(n){
if(n & 1) mul(r, a);
mul(a, a);
n >>= 1;
}
}
void solve()
{
int n;
cin >> n;
ll a[n];
vector<ll> p;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, n){
if(i && a[i] == a[i - 1]) p.pb(a[i++]);
}
sort(p.rbegin(), p.rend());
if(sz(p) <= 1) cout << 0;
else cout << p[0] * p[1];
}
int main()
{
// freopen("crosses.in", "r", stdin);
// freopen("crosses.out", "w", stdout);
Red;
int T = 1;
// cin >> T;
for(int i = 1; i <= T; ++i){
solve();
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <stack>
#define FOR(i,n) for(int i=0;i<n;i++)
using namespace std;
void makeStackRecur(vector<vector<int> > &g, int u, stack<int> &out, vector<bool> &seen) {
seen[u] = true;
for(int v: g[u])
if (! seen[v])
makeStackRecur(g, v, out, seen);
out.push(u);
}
void makeStack(vector<vector<int> > &g, int u, vector<bool> &seen, stack<int> &vStack) {
makeStackRecur(g, u, vStack, seen);
}
void getConnectedCompRecur(vector<int> &rootGroup, vector<vector<int> > &invGraph, int u, int root) {
if (rootGroup[u] == -1) {
rootGroup[u] = root;
for(int v: invGraph[u])
getConnectedCompRecur(rootGroup, invGraph, v, root);
}
}
void getConnectedComp(vector<int> &rootGroup, vector<vector<int> > &invGraph, stack<int> &vStack) {
while (! vStack.empty()) {
int u = vStack.top();
vStack.pop();
getConnectedCompRecur(rootGroup, invGraph, u, u);
}
}
int main () {
int V, E;
cin >> V >> E;
vector<vector<int> > graph(V);
vector<vector<int> > invGraph(V);
vector<bool> seen(V, false);
vector<int> rootGroup(V, -1);
FOR(i,E) {
int s, t;
cin >> s >> t;
graph[s].push_back(t);
invGraph[t].push_back(s);
}
stack<int> vStack;
FOR(i, V)
if (! seen[i]) makeStack(graph, i, seen, vStack);
FOR(i, V)
if (rootGroup[i] == -1) getConnectedComp(rootGroup, invGraph, vStack);
int Q;
cin >> Q;
FOR(i,Q) {
int f, t;
cin >> f >> t;
cout << (rootGroup[f] == rootGroup[t]) << endl;
}
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
long long MOD = 10000000000 + 7;
int main(){
cout << setprecision(10);
int N, u, v; cin >> N >> u >> v;
u--; v--;
vector<vector<int>> e(N);
for(int i = 0; i < N-1; i++){
int x,y; cin >> x >> y;
x--; y--;
e[x].push_back(y);
e[y].push_back(x);
}
vector<int> a(N,-1);
vector<int> t(N,-1);
t[u] = 0;
a[v] = 0;
queue<int> qt,qa;
qt.push(u);
while(!qt.empty()){
int now = qt.front();
qt.pop();
for(int next: e[now]){
if(t[next] == -1){
t[next] = t[now] + 1;
qt.push(next);
}
}
}
int dist = t[v];
qa.push(v);
while(!qa.empty()){
int now = qa.front();
qa.pop();
for(int next: e[now]){
if(a[next] == -1){
a[next] = a[now] + 1;
qa.push(next);
}
}
}
t[u] = 2;
int ans = 0;
for(int i = 0; i < N; i++){
if(a[i] >= t[i]){
ans = max(ans, a[i]);
}
}
cout << max(ans-1,0) << endl;
// cerr << "dist: " << dist;
}
| 0 |
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define REPD(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = a; i < int(b); i++)
#define FORD(i, a, b) for (int i = b - 1; i >= int(a); i--)
#define WRAP(y, x, h, w) (0 <= y && y < h && 0 <= x && x < w)
#define ALL(x) (x).begin(), (x).end()
int dx[4] = { 1, 0, -1, 0 };
int dy[4] = { 0, 1, 0, -1 };
int main()
{
string s;
cin >> s;
string ans = "No";
REP(i, 3)
if (s[i] == '7')
ans = "Yes";
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i,N) for (int i = 0; i < (N); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(void){
string S;
cin >> S;
int len = S.size();
int ans = 1000;
for (int i = 0; i < len - 2; i++){
int x = (S[i] - '0') * 100 + (S[i + 1] - '0') * 10 + (S[i + 2] - '0');
ans = min(abs(x - 753), ans);
}
cout << ans << endl;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = 4e18;
ll n, m, mn = M;
vector<ll> ve[1005];
vector<ll> ans;
vector<ll> now;
ll vv[1005];
void dfs(ll p)
{
if(now.size() != 0 && p == now[0])
{
if(mn > now.size())
{
mn = now.size();
ans = now;
}
return;
}
else if(vv[p]) return;
if(now.size() > mn) return;
vv[p] = true;
now.push_back(p);
for(ll i = 0; i < ve[p].size(); i++)
{
dfs(ve[p][i]);
}
// vv[p] = false;
now.pop_back();
}
int main()
{
scanf("%lld%lld", &n, &m);
for(ll i = 0; i < m; i++)
{
ll u, v;
scanf("%lld%lld", &u, &v);
ve[u].push_back(v);
}
for(ll i = 1; i <= n; i++)
{
for(ll i = 1; i <= n; i++) vv[i] = false;
dfs(i);
}
if(mn == M) printf("-1\n");
else
{
printf("%lld\n", mn);
for(ll i = 0; i < ans.size(); i++)
{
printf("%lld\n", ans[i]);
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for(ll i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for(ll i = (n) - 1; i >= 0; i--)
#define rreps(i, e, n) for(ll i = (n) - 1; i >= (e); i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define len(x) ((ll)(x).length())
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll n, m;
cin >> n >> m;
vector<vector<ll>> g(n), r(n);
rep(i, m) {
ll a, b;
cin >> a >> b;
a--; b--;
g[a].push_back(b);
r[b].push_back(a);
}
vector<ll> ans(n + 1);
rep(i, n) {
queue<ll> q;
vector<ll> dist(n, LONG_LONG_MAX);
vector<ll> prev(n, LONG_LONG_MAX);
q.push(i);
dist[i] = 0;
while(!q.empty()) {
ll now = q.front(); q.pop();
rep(ii, sz(g[now])) {
ll next = g[now][ii];
if (dist[next] <= (dist[now] + 1)) continue;
dist[next] = dist[now] + 1;
prev[next] = now;
q.push(next);
}
}
vector<ll> tmp;
q.push(i);
tmp.push_back(i);
while(!q.empty()) {
ll now = q.front(); q.pop();
ll mi = -1, mv = LONG_LONG_MAX;
rep(ii, sz(r[now])) {
ll next = r[now][ii];
if (mv <= dist[next]) continue;
mv = dist[next];
mi = next;
}
if ((mv == LONG_LONG_MAX) || (mi == i)) break;
tmp.push_back(mi);
q.push(mi);
}
if ((sz(tmp) == 1) || (sz(tmp) >= sz(ans))) continue;
reverse(tmp.begin() + 1, tmp.end());
ans = tmp;
}
if (sz(ans) == (n + 1)) {
cout << -1 << endl;
}
else {
cout << sz(ans) << endl;
rep(i, sz(ans)) cout << (ans[i] + 1) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
bool digits[10] = {false};
for (int i = 0; i < k; ++i) {
int x; cin >> x;
digits[x] = true;
}
while (n <= INT_MAX) {
int tmp = n;
while (tmp) {
int d = tmp % 10;
if (digits[d]) break;
else tmp /= 10;
}
if (tmp == 0) break;
else n++;
}
cout << n << "\n";
}
| #include <iostream>
#include <iomanip>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <cstdio>
#include <utility>
#include <string>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <numeric>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI=3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for(int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y) - 1) / (y))
#define MOD 1000000007ULL
#define IN(l, r, x) ((l) <= (x) && (x) < (r))
int h, w;
vector< string > field;
vector< vector< bool > > reached;
using P = pair<s64, s64>;
P dfs(int y, int x, char c)
{
P ret{0, 0};
if (c == '#') ret.first = 1;
else ret.second = 1;
reached[y][x] = true;
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, -1, 0, 1};
rep (i, 4)
{
int ny = y + dy[i];
int nx = x + dx[i];
if (IN(0, h, ny) && IN(0, w, nx) && !reached[ny][nx] && field[ny][nx] != c)
{
P temp = dfs(ny, nx, field[ny][nx]);
ret.first += temp.first;
ret.second += temp.second;
}
}
return ret;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> h >> w;
field.resize(h);
reached.resize(h, vector<bool>(w, false));
rep (i, h) cin >> field[i];
s64 ans = 0;
rep (i, h)
{
rep (j, w)
{
if (!reached[i][j] && field[i][j] == '#')
{
P p = dfs(i, j, '#');
ans += p.first * p.second;
}
}
}
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(long long)(n);i++)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const ll MOD=1e9+7;
const ll INF=1e18;
const int MAX=510000;
const double pi=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
int d[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
string s;
cin >> s;
rep(j,4){
vector<char>ans(n,'.');
if(j==0){
ans[0]='S';
ans[1]='S';
}
if(j==1){
ans[0]='S';
ans[1]='W';
}
if(j==2){
ans[0]='W';
ans[1]='S';
}
if(j==3){
ans[0]='W';
ans[1]='W';
}
bool ok = true;
rep(i,n){
if(s[i]=='o' && s[(i+1)%n]=='o'){
if(ans[i]=='S' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
if(ans[i]=='S' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
if(ans[i]=='W' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
if(ans[i]=='W' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
}
if(s[i]=='o' && s[(i+1)%n]=='x'){
if(ans[i]=='S' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
if(ans[i]=='S' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
if(ans[i]=='W' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
if(ans[i]=='W' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
}
if(s[i]=='x' && s[(i+1)%n]=='o'){
if(ans[i]=='S' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
if(ans[i]=='S' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
if(ans[i]=='W' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
if(ans[i]=='W' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
}
if(s[i]=='x' && s[(i+1)%n]=='x'){
if(ans[i]=='S' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
if(ans[i]=='S' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
if(ans[i]=='W' && ans[(i+1)%n]=='S'){
if(ans[(i+2)%n]=='W')ok=false;
ans[(i+2)%n]='S';
}
if(ans[i]=='W' && ans[(i+1)%n]=='W'){
if(ans[(i+2)%n]=='S')ok=false;
ans[(i+2)%n]='W';
}
}
}
if(ok){
rep(i,n)cout << ans[i];
return 0;
}
}
cout << -1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll=long;
#define V v[i]
int main(){
ll t;cin>>t;
while(t--){
ll n,Q=0;cin>>n;
vector<ll>v(n),N;
for(ll &p:v)cin>>p;
string s;cin>>s;
for(ll i=n-1;i>=0;i--){
for(ll p:N)V=min(V,V^p);
N.push_back(V);
Q|=s[i]=='1'&&V;
}
cout<<Q<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
#define REP(i, e) for(int (i) = 0; (i) < (e); ++(i))
#define FOR(i, b, e) for(int (i) = (b); (i) < (e); ++(i))
#define ALL(c) (c).begin(), (c).end()
#define PRINT(x) cout << (x) << "\n"
using namespace std;
using ll = long long; using pint = pair<int, int>; using pll = pair<ll, ll>;
template<typename T> auto compare = [](T x, T y) -> bool{return (x < y);};
const int MOD = 1000000007;
int N;
ll A[200010];
signed main(){
cin >> N;
REP(i, N) cin >> A[i];
REP(i, N){
if(i < A[i] || A[i] + 1 < A[i + 1]){
PRINT("-1");
return 0;
}
}
ll ans = 0;
for(int i = N - 1; i > 0; i--){
if(A[i - 1] < A[i]){
ans++;
}else{
ans += A[i];
}
}
PRINT(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A;
int B;
int C;
int D;
int L;
int R;
cin >> A >> B >> C >> D;
L = A + B;
R = C + D;
if (L > R){
cout << "Left" << endl;
}
else if (L == R) {
cout << "Balanced" << endl;
}
else if (L < R){
cout << "Right" <<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,Q;
cin >> N >> Q;
vector<int> data(N);
for(int i=0; i<N; i++){
cin >> data.at(i);
}
vector<int> cumsumL(N+1);
vector<int> cumsumR(N+1);
for(int i=1; i <= N; i++){
cumsumL.at(i)= cumsumL.at(i-1)+ data.at(i-1);
cumsumR.at(i)= cumsumR.at(i-1)+ data.at(N-i);
}
int QpopMAX= min(N, Q);
int ans= 0;
for(int Qpop=0; Qpop <= QpopMAX; Qpop++){
for(int QpopL=0; QpopL <= Qpop; QpopL++){
int QpopR= Qpop- QpopL;
priority_queue<int, vector<int>, greater<int>> items;
for(int i=0; i<QpopL; i++){
items.push(data.at(i));
}
for(int i=1; i<=QpopR; i++){
items.push(data.at(N-i));
}
int cand= cumsumL.at(QpopL)+ cumsumR.at(QpopR);
ans= max(ans, cand);
int Qpush= min(Q- Qpop, Qpop);
for(int q=0; q<Qpush; q++){
int cut_cand= items.top();
if(cut_cand < 0){
items.pop();
cand-= cut_cand;
ans= max(ans, cand);
}
else{
break;
}
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) {return (!b ? a : gcd(b, a % b));}
ll lcm(ll a, ll b) {return ((a*b)/gcd(a,b));}
bool cmp(int a,int b){return a>b;}
const ll mod = 1e9 + 7;
const int INF32 = 1<<30;
const ll INF64 = 1LL<<60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod)
{
if (k == 0) return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1) r = r * n % mod;
return r;
}
void solve(){
int n,k;cin >> n >> k;
vector<int>a(n);
int cnt = 0;
int sum = 0;
for(int i = 0;i<n;i++){
cin >> a[i];
if(a[i]>0) sum += a[i];
if(a[i]<0) cnt++;
}
if(k>=n+cnt){
cout << sum;
return;
}
vector<int>l(220,0);
multiset<int>ms;
l[0] = 0;int now = 0;
for(int i = 0;i<k;i++){
int cnt = 0;sum = 0;
now += a[i];
ms.insert(a[i]);
l[i+1] = max(l[i+1],max(l[i],now));
for(auto it : ms){
if(it<0) {cnt++;sum += it;l[i+cnt+1] = max(now-sum,l[i+cnt+1]);}
else break;
}
// cout << l[i+1] <<endl;
}
ms.clear();
vector<int>r(220,0);
r[0] = 0;
reverse(a.begin(),a.end());
now = 0;
for(int i = 0;i<k;i++){
int cnt = 0;sum = 0;
now += a[i];
ms.insert(a[i]);
r[i+1] = max(r[i+1],max(r[i],now));
for(auto it : ms){
if(it<0) {cnt++;sum += it;r[i+cnt+1] = max(r[i+cnt+1],now-sum);}
else break;
}
}
int ans = 0;
for(int i = 0;i<=k;i++){
ans = max(ans,r[i]+l[k-i]);
}
cout << ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef int64_t ll;
typedef uint64_t ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
// vector<vector<uint64_t> > v(n+1, vector<uint64_t>(n+1, 0))
// v[n][k]に組み合わせ数が入る。
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
// 掛け算オーバーフロー判定
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
//素因数分解
void primeFactorization(uint64_t a, list<uint64_t> &factors){ //素因数分解を出力するプログラム
long i,sq;
if(a%2==0){ //偶数の場合
factors.push_back(2);
primeFactorization(a/2,factors); //2で割った値で再帰
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){ //3以上√a以下の奇数の場合
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors); //割れた値で再帰
return;
}
}
//偶数でも3以上√a以下の奇数の場合でも割り切れない場合
if(a!=1){ //aが1でないなら、a自身は素数
factors.push_back(a);
}
}
// フェルマーの小定理
// mod. m での a の逆元 a^{-1} を計算する
// (a/b)%m = a*movinv(b,m)%m
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
/*
//エラトステネスのふるい
int maxNum = 100000;
char isNotPrime[maxNum+1] = {};
isNotPrime[0]=isNotPrime[1]=1;
for(int i=2;i<maxNum;i++){
if(isNotPrime[i]==1) continue;
int num = i+i;
while(num<=maxNum){
isNotPrime[num]=1;
num += i;
}
}
*/
// 円周率
// M_PI
// #include <iomanip> // setprecisionを使用するのに必要
// cout << std::fixed << std::setprecision(15) << y << endl;
// 昇順
// priority_queue<int, vector<int>, greater<int> > queue;
// 降順ソート vector<int> v;
// sort(v.begin(),v.end(),greater<int>());
signed main() {
ll n,t;
cin >> n >> t;
ll total = 0;
int a = 0;
int prevA = -t-1;
for(int i=0;i<n;i++){
cin >> a;
total += t;
if(a-prevA<=t){
total -= t-(a-prevA);
}
prevA = a;
}
cout << total << endl;
return 0;
}
| #include<iostream>
using namespace std;
int main(){
int n,t;
cin>>n>>t;
int a[n];
long long ans=0;
cin>>a[0];
for(int i=1;i<n;i++){
cin>>a[i];
if(a[i]-a[i-1]>t){
ans+=t;
}else{
ans+=a[i]-a[i-1];
}
}
ans+=t;
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
using ll = long long;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define input(...) __VA_ARGS__; in(__VA_ARGS__)
template<class T>
void print(vector<T> a) {
cout << "[ ";
REP(i, a.size()) cout << a[i] << " ";
cout << "]" << endl;
}
void print() {
std::cout << std::endl;
}
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
std::cout << head << " ";
print(std::forward<Tail>(tail)...);
}
void in() { }
template <class Head, class... Tail>
void in(Head&& head, Tail&&... tail) {
cin >> head;
in(std::forward<Tail>(tail)...);
}
ll n, x;
vector<ll> s;
vector<vector<ll>> table;
ll MOD = 1000000000 + 7;
ll powmod(ll v, ll x) {
if (x == 0) return 1;
if (x % 2 == 0) {
ll tmp = powmod(v, x / 2);
return (tmp * tmp) % MOD;
} else {
return (powmod(v, x - 1) * v) % MOD;
}
}
#define DP table[i][a]
ll dfs(ll i, ll a) {
if (DP != -1) return DP;
if (i == n) return DP = a;
// double p = 1. / (n - i);
ll p = powmod(n - i, MOD - 2);
return DP = ((dfs(i + 1, a % s[i]) * p) % MOD + (dfs(i + 1, a) * ((1 - p + MOD) % MOD)) % MOD) % MOD;
/* if (i == n - 1) return DP = a % s[n - 1]; */
/* return DP = (dfs(i + 1, a % s[i]) + dfs(i + 1, a)) % MOD; */
}
int main() {
cin >> n >> x;
s = vector<ll>(n);
REP(i, n) cin >> s[i];
sort(s.begin(), s.end(), greater<ll>());
table = vector<vector<ll>>(n + 1, vector<ll>(x + 1, -1));
ll fact = 1;
FOR(i, 1, n) {
(fact *= i) %= MOD;
}
cout << dfs(0, x) * fact % MOD << endl;
}
| #include<cstdio>
#include<algorithm>
using namespace std;
const int N=2010;
int n,m,ans,a[N][N],up[N],L[N],R[N];
char s[N];
int main(){
scanf("%d%d",&n,&m);ans=max(n,m);
for(int i=1;i<=n;i++){
scanf("%s",s+1);
for(int j=1;j<=m;j++)
a[i][j]=s[j]=='.'?0:1;
}
--n;--m;
for(int i=1;i<=m;i++)L[i]=1,R[i]=m;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
a[i][j]^=a[i+1][j]^a[i][j+1]^a[i+1][j+1];
for(int i=1;i<=n;i++){
int l=0,r=m+1;
for(int j=1;j<=m;j++)
if(a[i][j])up[j]=0,l=j,L[j]=1;
else ++up[j],L[j]=max(L[j],l+1);
for(int j=m;j;j--)
if(a[i][j])r=j,R[j]=m;
else {
R[j]=min(R[j],r-1);
ans=max((R[j]-L[j]+2)*(up[j]+1),ans);
}
}
printf("%d\n",ans);
} | 0 |
#include<iostream>
#include<cstdio>
using namespace std;
int main() {
int siz[6], damy;
char mozi[2];
for (int abc = 0; abc < 6; abc++) {
cin >> siz[abc];
}
fgets(mozi,2,stdin);
while(true){
fgets(mozi,2,stdin);
if (mozi[0] == '\n') {
cout << siz[0] << endl;
break;
}
switch (mozi[0]) {
case 'S':
damy = siz[0];
siz[0] = siz[4];
siz[4] = siz[5];
siz[5] = siz[1];
siz[1] = damy;
break;
case 'E':
damy = siz[0];
siz[0] = siz[3];
siz[3] = siz[5];
siz[5] = siz[2];
siz[2] = damy;
break;
case 'N':
damy = siz[0];
siz[0] = siz[1];
siz[1] = siz[5];
siz[5] = siz[4];
siz[4] = damy;
break;
case 'W':
damy = siz[0];
siz[0] = siz[2];
siz[2] = siz[5];
siz[5] = siz[3];
siz[3] = damy;
break;
}
}
return 0;
} | #include<iostream>
#include<stdio.h>
#include<string>
#include<math.h>
#include<iomanip>
#include<algorithm>
#include<string.h>
#include<cctype>
#include<map>
#include<set>
#include<vector>
#include<sstream>
#include<stack>
#include<queue>
#include<functional>
#include<utility>
using namespace std;
int main()
{
int up,down,front,back,left,right;
cin>>up>>front>>right>>left>>back>>down;
string com;
cin>>com;
for(int i=0;i<com.length();i++)
{
if(com[i]=='S')
{
int temp=down;
down=front;
front=up;
up=back;
back=temp;
}
else if(com[i]=='W')
{
int temp=left;
left=up;
up=right;
right=down;
down=temp;
}
else if(com[i]=='N')
{
int temp=front;
front=down;
down=back;
back=up;
up=temp;
}
else
{
int temp=up;
up=left;
left=down;
down=right;
right=temp;
}
}
cout<<up<<endl;
//while(1);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
for(int i = 1; i <= n; i++){
if(i % 3 == 0 && i % 5 == 0) {
//FizzBuzz
} else if(i % 3 == 0) {
//Fizz
} else if(i % 5 == 0) {
//Buzz
} else {
ans = ans + i;
}
}
cout << ans;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
long long int n;
cin>>n;
cout<<(1+n)*n/2-(3+n-n%3)*(n-n%3)/3/2-(5+n-n%5)*(n-n%5)/5/2+(15+n-n%15)*(n-n%15)/15/2<<endl;
}
| 1 |
#include <iostream> // cout, endl, cin
#include <cmath> //sqrt pow
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#define rep(i,n) for(int i = 0; i < n; i++)
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int, int>
#define mod 1000000007
using ll = long long;
using namespace std;
int main(){
int k,t;
cin >> k >> t;
vi a(t);
int maxnum = 0, pos;
rep(i, t){
cin >> a[i];
if(a[i] > maxnum){
maxnum = a[i];
pos = t;
}
}
int ans = maxnum - 1;
ans = max(ans - k + maxnum, 0);
cout << ans << endl;
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<utility>
#include<cmath>
#include<climits>
#include<queue>
#include<stack>
#include<numeric>
#include<set>
#include<iomanip>
#include<map>
#include<type_traits>
#include<tuple>
#include<deque>
#include<cassert>
#include<bitset>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,N) for(int (i)=0;(i)<(N);(i)++)
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
const double PI = 3.1415926535897932384626433832795;
const int mod = 1000000007;
const int INF = 1001001001;
int dp[400][400];
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
int h, w;
vector<vector<bool>> used(400, vector<bool>(400));
ll black = 0, white = 0;
void dfs(int x, int y, vector<string> &s) {
if (used[x][y]) return;
used[x][y] = true;
if (s[x][y] == '.') white++;
else black++;
char cur = s[x][y];
rep(i, 4) {
int nx = dx[i] + x;
int ny = dy[i] + y;
if (0 <= nx && nx < h && 0 <= ny && ny < w) {
char next = s[nx][ny];
if (next != cur) {
dfs(nx, ny, s);
}
}
}
}
int main() {
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
ll ans = 0;
rep(i, h) rep(j, w) {
black = white = 0;
dfs(i, j, s);
ans += black * white;
}
cout << ans << endl;
} | 0 |
#include <cstdio>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <unordered_map>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD=998244353;
ll powmod(ll a, ll k){
ll ap=a, ans=1;
while(k){
if(k&1){
ans*=ap;
ans%=MOD;
}
ap=ap*ap;
ap%=MOD;
k>>=1;
}
return ans;
}
ll inv(ll a){
return powmod(a, MOD-2);
}
int main()
{
int n, m;
cin>>n>>m;
if(n<m) swap(m, n);
ll f[1000001]; f[0]=1;
for(ll i=1; i<=n+m; i++) f[i]=f[i-1]*i%MOD;
ll invf[1000001];
invf[n+m]=inv(f[n+m]);
for(ll i=n+m-1; i>=0; i--) invf[i]=invf[i+1]*(i+1)%MOD;
ll ans=n;
ll tot=f[n+m]*invf[n]%MOD*invf[m]%MOD;
ll tinv=inv(tot);
for(int i=0; i<m; i++){
ans+=f[n-m+2*i]*invf[i]%MOD*invf[n-m+i]%MOD*f[2*m-2*i-1]%MOD*invf[m-i]%MOD*invf[m-i-1]%MOD*tinv%MOD;
ans%=MOD;
}
cout<<ans<<endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#define llint long long
#define mod 1000000007
using namespace std;
llint n;
llint a[500005], s[500005];
llint z[500005];
vector<llint> vec[500005];
llint sum[500005];
llint dp[500005];
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for(int i = 1; i <= n; i++) cin >> a[i];
for(int i = 1; i <= n; i++) s[i] = s[i-1] ^ a[i];
bool flag = false;
for(int i = 1; i <= n; i++){
if(s[i] == 0) flag = true;
}
if(!flag){
cout << 1 << endl;
return 0;
}
vector<llint> comp;
for(int i = 1; i <= n; i++) comp.push_back(s[i]);
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end());
for(int i = 1; i <= n; i++) s[i] = lower_bound(comp.begin(), comp.end(), s[i]) - comp.begin();
llint S = s[n];
for(int i = 1; i <= n; i++) vec[s[i]].push_back(i);
for(int i = 1; i <= n; i++){
z[i] = z[i-1];
if(s[i] == 0) z[i]++, z[i] %= mod;
}
//for(int i = 1; i <= n; i++) cout << s[i] << " "; cout << endl;
//cout << S << endl;
llint ans = 0;
for(int i = 1; i < 500005; i++){
llint N = vec[i].size();
if(N == 0) continue;
llint have = 0, sum = 0;
dp[0] = 1, have++;
for(int j = 1; j < N; j++){
sum += have * (z[vec[i][j]] - z[vec[i][j-1]] + mod) % mod, sum %= mod;
dp[j] = sum+1;
have += dp[j], have %= mod;
}
if(S == 0){
for(int j = 0; j < N; j++) ans += dp[j], ans %= mod;
}
else{
if(i == S) ans += dp[N-1], ans %= mod;
}
//for(int j = 0; j < N; j++) cout << dp[j] << " "; cout << endl;
}
//cout << ans << endl;
if(S == 0){
llint tmp = 1;
for(int i = 1; i < vec[0].size(); i++) tmp *= 2, tmp %= mod;
ans += tmp, ans %= mod;
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
using Graph = vector<vector<int>>;
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
struct edge{ll to, cost;};
typedef pair<ll,ll> P;
struct graph{
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n){
init(n);
}
void init(ll n){
V = n;
G.resize(V);
d.resize(V);
rep(i,V){
d[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost){
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s){
rep(i,V){
d[i] = INF;
}
d[s] = 0;
priority_queue<P,vector<P>, greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P p = que.top(); que.pop();
ll v = p.second;
if(d[v]<p.first) continue;
for(auto e : G[v]){
if(d[e.to]>d[v]+e.cost){
d[e.to] = d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
}
};
class UnionFind
{
public:
int par[100005];
int depth[100005];
int nGroup[100005];
UnionFind(int n) {
init(n);
}
void init(int n) {
for(int i=0; i<n; i++) {
par[i] = i;
depth[i] = 0;
nGroup[i] = 1;
}
}
int root(int x) {
if(par[x] == x) {
return x;
} else {
return par[x] = root(par[x]);
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if(x == y) return;
if(depth[x] < depth[y]) {
par[x] = y;
nGroup[y] += nGroup[x];
nGroup[x] = 0;
} else {
par[y] = x;
nGroup[x] += nGroup[y];
nGroup[y] = 0;
if(depth[x] == depth[y])
depth[x]++;
}
}
};
const ll MAX = 510000;
ll fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<ll> depth;
vector<ll> f;
vector<ll> g;
void dfs(const Graph &G, ll v, ll p, ll d) {
depth[v] = d;
for (auto nv : G[v]) {
if (nv == p) continue; // nv が親 p だったらダメ
dfs(G, nv, v, d+1);
}
// 帰りがけ時に、部分木サイズを求める
f[v] = 1;
g[v] = 1;// 自分自身
for (auto c : G[v]) {
if (c == p) continue;
f[v]*=g[c];
f[v]%=MOD;
g[v]*=f[c];
g[v]%=MOD;
}
f[v]+=g[v];
f[v]%=MOD;
}
int main() {
ll n,m; cin>>n>>m;
ll a[n]={};
rep(i,n) cin>>a[i];
map<ll,ll> b;
ll ca = 0;
rep(i,n){
ca+=a[i];
ll r = ca%m;
ca%=m;
b[r]++;}
ll ans = 0;
for(auto p : b){
if(p.fi==0)
ans+=p.se*(p.se+1)/2;
else
ans+=p.se*(p.se-1)/2;}
cout << ans << endl;}
| #include <bits/stdc++.h>
using namespace std;
// type alias
typedef long long LL;
typedef pair<int,int> II;
typedef tuple<int,int,int> III;
typedef vector<int> VI;
typedef vector<string> VS;
typedef unordered_map<int,int> MAPII;
typedef unordered_set<int> SETI;
template<class T> using VV=vector<vector<T>>;
// minmax
template<class T> inline T SMIN(T& a, const T b) { return a=(a>b)?b:a; }
template<class T> inline T SMAX(T& a, const T b) { return a=(a<b)?b:a; }
// repetition
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) for(int i=0;i<=(n);++i)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define FORR(x,arr) for(auto& x:arr)
#define SZ(a) int((a).size())
// collection
#define ALL(c) (c).begin(),(c).end()
// DP
#define MINUS(dp) memset(dp, -1, sizeof(dp))
#define ZERO(dp) memset(dp, 0, sizeof(dp))
// stdout
#define println(args...) fprintf(stdout, ##args),putchar('\n');
// debug cerr
template<class Iter> void __kumaerrc(Iter begin, Iter end) { for(; begin!=end; ++begin) { cerr<<*begin<<','; } cerr<<endl; }
void __kumaerr(istream_iterator<string> it) { (void)it; cerr<<endl; }
template<typename T, typename... Args> void __kumaerr(istream_iterator<string> it, T a, Args... args) { cerr<<*it<<"="<<a<<", ",__kumaerr(++it, args...); }
template<typename S, typename T> std::ostream& operator<<(std::ostream& _os, const std::pair<S,T>& _p) { return _os<<"{"<<_p.first<<','<<_p.second<<"}"; }
#define __KUMATRACE__ true
#ifdef __KUMATRACE__
#define dump(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); __kumaerr(_it, args); }
#define dumpc(ar) { cerr<<#ar<<": "; FORR(x,(ar)) { cerr << x << ','; } cerr << endl; }
#define dumpC(beg,end) { cerr<<"~"<<#end<<": "; __kumaerrc(beg,end); }
#else
#define dump(args...)
#define dumpc(ar)
#define dumpC(beg,end)
#endif
// $ cp-batch Test | diff Test.out -
// $ g++ -std=c++14 -Wall -O2 -D_GLIBCXX_DEBUG -fsanitize=address Test.cpp && ./a.out
/*
5/25/2020
16:11-
*/
const int MAX_N=1e6+1;
LL A[MAX_N];
int N,M;
void solve() {
LL res=0;
map<int,int> cnt;
cnt[0]=1;
LL cur=0;
REP(i,N) {
cur+=A[i];
res+=cnt[cur%M];
cnt[cur%M]++;
}
cout<<res<<endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout<<setprecision(12)<<fixed;
cin>>N>>M;
REP(i,N) cin>>A[i];
solve();
return 0;
}
| 1 |
#include<iostream>
#include <algorithm>
#include <cmath>
#include <set>
#include<map>
#include<cstring>
#include<iomanip>
#include <string>
#include <vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long unsigned llu;
typedef long double ld;
#define ll long long
#define PI 3.14159265358979323846
#define For(i, a, b) for (int i = a, sz = (int)b; i < sz; i++)
#define rFor(i, a, b, c) for (int i = (a); i >= (b); i -= (c))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define fill(a, b) memset(a, b, sizeof(a))
#define IO ios_base::sync_with_stdio(false), cin.tie(0),cout.tie(0)
const int mod = 1000000007;
const ll inf = 1000000000009;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b) { return a*b/gcd(a,b);}
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdoutn
int main() {
IO;
int a, b, x, y, r, c, ans;
cin >> a >> b;
x = a / 1000, y = b / 1000, r = (a / 100) % 10, c = (b / 100) % 10;
ans = (y - x - 1) * 10 + 10 - r + c + 1;
if (a > (a / 100) * 100 + ((a / 1000) % 10) * 10 + (a / 10000))
ans--;
if (b < (b / 100) * 100 + ((b / 1000) % 10) * 10 + (b / 10000))
ans--;
printf("%d\n", ans);
// system("pause");
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
int main (void)
{
int n,r,k;
cin>>n>>r;
k=10;
if(n<10){k=n;}
r=r+100*(10-k);
cout<<r;
return 0;
}
| 0 |
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
//#define int long long
#define ALL(x) begin(x),end(x)
#define RALL(a) (a).rbegin(), (a).rend()
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
const int MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 25;
constexpr long double pi = 3.141592653589793238462643383279;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(ll i) {
if (i == 0) return 1;
return ((fact(i - 1)) * i) % MOD;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll keta(ll n) {
if (n == 0) return 1;
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll mch(ll n) {
if (n == 1) return 1;
else return n * mch(n - 1);
}
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1) hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false; // (6の倍数)-1
if (n % (i + 2) == 0) return false; // (6の倍数)+1
}
return true;
}
/*signed*/int main(void) {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
rep(i, m) {
int s, c;
cin >> s >> c;
s--;
p[i] = make_pair(s, c);
}
rep(i, 1000) {
string s = to_string(i);
if (s.size() == n) {
bool ans = true;
rep(j, m) {
if ((s[p[j].first] - '0') != p[j].second)ans = false;
}
if (ans) {
cout << i << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
} | #include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <bitset>
#include <set>
#include <unordered_set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define ALL(v) v.begin(),v.end()
template < class T > inline bool chmax(T& a, T b) {if (a < b) { a=b; return true; } return false; }
template < class T > inline bool chmin(T& a, T b) {if (a > b) { a=b; return true; } return false; }
#define DEBUG_VLL(vec) for(int sz=0;sz<int(vec.size());sz++) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');
const long long MOD = 1000000007;
const long long HIGHINF = (long long)1e18;
const int INF = (int)1e9;
using PI = P<int, int>;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, t; cin >> n >> t;
V<PI> ab(n);
for (int i = 0; i < n; i++) cin >> ab[i].first >> ab[i].second;
sort(ALL(ab), [&](PI &i, PI &j){
return i.first < j.first;
});
V< V<int> > dp(n + 1, V<int>(t + 1, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j <= t; j++) {
chmax(dp[i + 1][j], dp[i][j]);
if (j < t) chmax(dp[i + 1][min(j + ab[i].first, t)], dp[i][j] + ab[i].second);
}
}
cout << *max_element(ALL(dp[n])) << '\n';
return 0;
}
| 0 |
#include <cstdio>
#include <cstring>
#define MAX_N 105
int N, A, B, C, D, S[MAX_N + 1];
int main()
{
scanf("%d", &N);
for (int i = 0; i < (N * N - N) / 2; i++)
{
scanf("%d", &A);
scanf("%d", &B);
scanf("%d", &C);
scanf("%d", &D);
if (C > D) { S[A] += 3; }
if (C < D) { S[B] += 3; }
if (C == D) { S[A] += 1; S[B] += 1; }
}
int rank;
for (int i = 1; i <= N; i++)
{
rank = 1;
for (int j = 1; j <= N; j++)
{
if (S[i] < S[j]) { rank += 1; }
}
printf("%d\n", rank);
}
return 0;
} | #include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
struct comparator {
int operator() (const pair<int, int>& l, const pair<int, int>& r) {
return l.second < r.second;
}
};
int main(int argc, char *argv[]) {
// second = team's number
vector<pair<int, int> >team;
int n, a, b, c, d, game;
cin >> n;
for (int i = 0; i < n; i++)
team.push_back(pair<int, int>(0, i));
game = n * (n-1) / 2;
for (int i = 0; i < game; i++) {
cin >> a >> b >> c >> d;
if (c > d) {
team[a-1].first += 3;
} else if (c < d) {
team[b-1].first += 3;
} else {
team[a-1].first++;
team[b-1].first++;
}
}
sort(team.rbegin(), team.rend());
int points = -1, rank = 1;
for (int i = 0; i < n; i++)
if (team[i].first == points) {
team[i].first = rank;
} else {
points = team[i].first;
team[i].first = i+1;
rank = i+1;
}
struct comparator comp;
sort(team.begin(), team.end(), comp);
for (int i = 0; i < n; i++)
cout << team[i].first << endl;
return 0;
} | 1 |
#include <iostream>
#include <cmath>
#include <map>
#include <set>
using namespace std;
int main() {
int n;
scanf("%d", &n);
map<pair<int, int>, set<int>> pair_index;
for(int i=0; i<n; i++){
double x;
int pow2=0, pow5=0;
unsigned long long val;
scanf("%lf", &x);
val=llround(x*1e9);
while(val%2==0){
pow2++;
val/=2;
}
while(val%5==0){
pow5++;
val/=5;
}
pair_index[*new pair(pow2, pow5)].insert(i);
}
unsigned long long counter=0;
for(auto i=pair_index.begin(); i!=pair_index.end(); i++){
for(auto j=i; j!=pair_index.end(); j++){
if(min(i->first.first+j->first.first, i->first.second+j->first.second)>=18){
if(i==j){
counter+=i->second.size()*(j->second.size()-1)/2;
}else if(*i<*j){
counter+=(i->second.size()*j->second.size());
}
}
}
}
printf("%llu\n", counter);
return 0;
}
/*Logic:
* Since floating points are stored as approximate value.
* Direct multiplication will result in some anomaly.
* To avoid that we multiplied the given floating point or regular number
* with 10^9, because the highest number of digits after decimal is 9.
* This will make the numbers to be in the form
* number/10^9.
* Now, if we multiply say (x/10^9 * y/10^9) then we get
* xy/10^18.
* To get an integer, all we have to do is cancel out the denominator.
* So xy has be z*(10^(>=9)).
* Now we also know that 10^p is basically (2^p)*(5^p).
* Here, p has to be equal to or greater that 9.
*
* Now, comes to the problem of handling TLE.
* Since the dataset is 2*10^6 and 2 sec, regular brute force gave me TLE.
* So in order to handle that a map with key (2^p)*(5^q) where p varies and q varies
* and as value stores the indices of where key was found.
* Now, for any pair of keys min(p1+p2, q1+q2) >=18, then all we multiply the number
* of values from the keys.
* If for the same key min(p1+p1, q1+q1) >=18, then all possible combinations are required.
* Thus number of values*(number of values-1)/2.
* Summation of all of these results in the answer.
*/ | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(NAME, NUM) for (int NAME = 0; NAME < (NUM); ++NAME)
#define BREP(NAME, NUM) for (int NAME = (NUM)-1; NAME >= 0; --NAME)
#define ALL(NAME) (NAME).begin(), (NAME).end()
#define cMOD 998244353;
int main()
{
ll n = 0;
cin >> n;
vector<ll> a( n, 0 );
REP(i,n)cin>>a[i];
ll sum = 0;
REP(i,n) sum += a[i];
vector<ll> dp( sum + 1, 0 );
vector<ll> dp2( sum + 1, 0 );
dp[0] = 1;
dp2[0] = 1;
REP( i, n ) BREP( j, sum + 1 )
{
dp[j] *= 2;
if( a[i] <= j ) dp[j] += dp[j - a[i]];
dp[j] %= cMOD;
if( a[i] <= j ) dp2[j] += dp2[j - a[i]];
dp2[j] %= cMOD;
//cout << i << " " << j << " " << dp2[j] << endl;
}
ll ans = 0;
for( int i= ( sum + 1 ) / 2; i <= sum; ++i )
ans = ( ans + dp[i] ) % cMOD;
ll all = 1;
REP( i, n ) all = ( all * 3 ) % cMOD;
ans = all - ans * 3;
if( sum % 2 == 0 ) ans = ans + dp2[sum/2] * 3;
while( ans < 0 ) ans += cMOD;
ans %= cMOD;
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
typedef long long ll;
#define PI acos(-1)
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(), (a).end()
#define clr(a,h) memset(a, (h), sizeof(a))
#define F first
#define S second
#define fore(i,b,e) for(int i=(int)b;i<(int)e;++i)
#define forr(i,b,e) for(int i=(int)b;i<(int)e;++i)
int faster_in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -faster_in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}
using namespace std;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<ll> vll;
const int INF = 1234567890;
ll toLL(string s) {
ll res = 0;
fore (i,0,s.length()) {
res *= 10LL;
res += s[i] - '0';
}
return res;
}
ll pot[45][20][10];
int main()
{
std::ios::sync_with_stdio(false); cin.tie(0);
//freopen("","r",stdin);
//freopen("","w",stdout);
int n;
cin >> n;
ll res = 0;
fore(i, 0, n) {
string s;
cin >> s;
int decimal = 0;
fore(j, 0, s.length()) {
decimal++;
if (s[j] == '.') {
decimal = 0;
}
}
if (decimal == (int)s.length()) {
decimal = 0;
}
string s2 = "";
fore(j, 0, s.length()) {
if (s[j] != '.') {
s2 += s[j];
}
}
ll a = toLL(s2);
int p2 = 0, p5 = 0;
while (a%2 == 0) {
p2++;
a /= 2;
}
while (a%5 == 0) {
p5++;
a /= 5;
}
//cout << "2^" << p2 << " 5^" << p5 << " con " << decimal << " decimales" << endl << endl;
pot[p2][p5][decimal]++;
//if (min(p2, p5) >= decimal*2) res--;
}
ll ans = 0;
res = 0;
fore(a, 0, 45) {
fore(b, 0, 20) {
fore(c, 0, 10) {
fore(x, 0, 45) {
fore(y, 0, 20) {
fore(z, 0, 10) {
if (x == a && y == b && z == c) {
if (pot[a][b][c] > 1 && min(2*a, 2*b) >= 2*c) {
ans += pot[a][b][c] * (pot[a][b][c]-1) / 2;
}
}
else if ( min( a+x, b+y ) >= c + z ) {
res += pot[a][b][c] * pot[x][y][z];
}
}
}
}
}
}
}
cout << res/2 + ans << '\n';
return 0;
}
// PLUS ULTRA! | #include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <cmath>
using namespace std;
typedef long long int ll;
#define all(x) x.begin(),x.end()
const ll mod = 1e9+7;
const ll INF = 1e9;
const ll MAXN = 1e9;
int main()
{
int n;
cin >> n;
vector<int> v(n);
for(int i = 0; i < n; i++){
cin >> v[i];
}
map<int,int> even,odd; //mapで各数列での要素の出現数を記録する
for(int i = 0; i < n; i++){
if(i%2==0) odd[v[i]]++;
else even[v[i]]++;
}
int even_1=0,even_2=0,odd_1=0,odd_2=0;
int e1=0,e2=0,o1=0,o2=0;
int cnt = 0;
for(auto itr = even.begin(); itr != even.end() ; ++itr){
if(itr->second > cnt){
cnt = itr->second;
even_1 = itr->first;
}
}
e1 = cnt;
cnt = 0;
for(auto itr = even.begin(); itr != even.end() ; ++itr){
if(itr->second > cnt && itr->first != even_1){
cnt = itr->second;
even_2 = itr->first;
}
}
e2 = cnt;
cnt = 0;
for(auto itr = odd.begin(); itr != odd.end() ; ++itr){
if(itr->second > cnt){
cnt = itr->second;
odd_1 = itr->first;
}
}
o1= cnt;
cnt = 0;
for(auto itr = odd.begin(); itr != odd.end() ; ++itr){
if(itr->second > cnt && itr->first != odd_1){
cnt = itr->second;
odd_2 = itr->first;
}
}
o2=cnt;
if(even_1 == odd_1){
cout << min(n-e1-o2, n-e2-o1) << endl;
}else{
cout << n-e1-o1 << endl;
}
return 0;
} | 0 |
Subsets and Splits