code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = (0); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define DEBUG(val) cout << #val << " : " << val << endl
#define MOD 1000000007
int main() {
int k, t;
cin >> k >> t;
int ans = 0;
int prev = -1;
priority_queue<pair<int, int>> data;
REP(i, t) {
int x;
cin >> x;
pair<int, int> p = make_pair(x, i + 1);
data.push(p);
}
while (!data.empty()) {
pair<int, int> p1 = data.top();
data.pop();
if (data.empty()) {
ans += (p1.first - 1);
break;
}
pair<int, int> p2 = data.top();
data.pop();
if (p1.first != 1) {
pair<int, int> p = make_pair(p1.first - 1, p1.second);
data.push(p);
}
if (p2.first != 1) {
pair<int, int> p = make_pair(p2.first - 1, p2.second);
data.push(p);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define INF 1000000001
//A=65,a=97
int main() {
int k,t;cin >> k >> t;
vector<int> a(t);for(int i=0;i<t;i++) cin >> a[i];
sort(a.begin(),a.end());
if(a[t-1]<=(k+1)/2){
cout << 0 << endl;
return 0;
}
a[t-1] -= k-a[t-1];
cout << a[t-1]-1 << endl;
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <queue>
#include <stack>
#include <tuple>
#include <cmath>
#include <iomanip>
#include <map>
#include <stdio.h>
#include <cstring> //memset(dp,0,sizeof(dp))
#include <functional>
#define ll long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define fi first
#define se second
#define pb push_back
#define ALL(a) (a).begin(),(a).end()
using namespace std;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
typedef pair<int,int> P;
typedef pair<ll,ll> Pll;
//小数点以下 cout << fixed << setprecision(10) << num << endl;
//桁数はlog10(mid)でやれ log(mid)/log(10)はWA
//long*long<0で判定するな
//開区間と閉区間
//アルファベットが何番目かは x=s[i]-'a'
//bfsはmain()内で rep(i,h)rep(j,w)rep(i,4)でバグ
//切り上げ：(a+(b-1))/b
//32bit以上は 1ull<<j
// map 初期値0 for(auto itr=mp.begin();itr!=mp.end();++itr) itr->fi itr->se で全探索
// for(auto u:mp) u.fi u.se も可能
//n個のgcd,lcmは一つずつみて更新していく
//大きな数を扱うときは素因数分解した形で持っておく
// (l/a[i]) = l*powmod(a[i],MOD-2)%MOD;
//auto itr=lower_bound(ALL(a),key) a[itr-a.begin()]
const ll MOD = 1000000007;
signed main(){
int h,w,k;
cin >> h >> w >> k;
k--;
if(w==1){
if(k==0) cout << 1 << endl;
else cout << 0 << endl;
return 0;
}
ll num[w-1],no[w];
rep(i,w-1) num[i]=0;
rep(i,w) no[i]=0;
rep(i,(1<<(w-1))){
bool kuji[w-1];
rep(j,w-1){
if(i&(1<<j)){
kuji[j]=1;
}else kuji[j]=0;
}
bool aa=0;
rep(j,w-2) if(kuji[j]&&kuji[j+1]) aa=1;
if(aa) continue;
rep(j,w-1){
if(kuji[j]) num[j]++;
if(0<j&&!kuji[j]&&!kuji[j-1]) no[j]++;
}
if(!kuji[0]) no[0]++;
if(!kuji[w-2]) no[w-1]++;
}
ll dp[h+1][w];
memset(dp,0,sizeof(dp));
dp[0][0]=1;
rep(i,h+1){
if(i==0) continue;
rep(j,w){
if(j>0) dp[i][j]+=(dp[i-1][j-1]*num[j-1])%MOD;
dp[i][j]%=MOD;
if(j+1<w) dp[i][j]+=(dp[i-1][j+1]*num[j])%MOD;
dp[i][j]%=MOD;
dp[i][j]+=(dp[i-1][j]*no[j])%MOD;
dp[i][j]%=MOD;
}
}
cout << dp[h][k] << endl;
}
| /*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 62;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
return f.second > s.second;
}
ll gcd(ll a, ll b){
if (b == 0)return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
ll nCr(ll n, ll r){
if(r == 0 || r == n){
return 1;
} else if(r == 1){
return n;
}
return (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r){
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--) ret *= i;
return ret;
}
//-----------------------ここから-----------
ll h, w, k;
ll memo[110][10];
ll rec(ll i, ll j){
if(i == 0 && j == 0) return 1;
if(i == 0) return 0;
if(memo[i][j] != -1) return memo[i][j];
ll res = 0;
//cout << i << " " << j << endl;
for(ll bit = 0; bit < (1LL << (w - 1)); bit++){
bool ok = true;
for(ll ii = 0; ii < w - 2; ii++){
if((bit & (1LL << ii)) && (bit & (1LL << (ii + 1)))){
ok = false;
break;
}
}
if(ok){
if(bit & (1LL << j) && j + 1 < w){
res += rec(i - 1, j + 1);
} else if(bit & (1 << (j - 1)) && j - 1 >= 0){
res += rec(i - 1, j - 1);
} else {
res += rec(i - 1, j);
}
res %= MOD;
}
}
return memo[i][j] = res;
}
int main(void){
cin >> h >> w >> k;
rep(i, 110) rep(j, 10) memo[i][j] = -1;
cout << rec(h, k - 1) % MOD << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
#define DEBUG freopen("in.txt", "r", stdin);
struct fastio {
fastio() {
ios::sync_with_stdio(false);
cout << setprecision(10) << fixed;
cin.tie(0);
}
};
fastio _fast_io;
const int N = 1e5 + 5;
int n, m, k;
int a[N];
ll ans;
int main() {
cin >> n >> k;
m = n;
ans = LLONG_MAX;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (m == n && a[i] >= 0) {
m = i;
}
}
for (int i = 0; i <= min(k, m); ++i) {
if (m + k - i - 1 >= n) continue;
ll lv = 0;
ll rv = 0;
if (i)
lv = -a[m - i];
if (k - i)
rv = a[m + k - i - 1];
// cout << i << ' ' << lv << ' ' << rv << endl;
ans = min(ans, min(lv, rv) * 2 + max(lv, rv));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit32(x) (1 << (x))
#define bit64(x) (1ll << (x))
#define sz(v) ((int) v.size())
using namespace std;
using i64 = long long;
using f80 = long double;
using vi32 = vector<int>;
using vi64 = vector<i64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() { cout << "Yes" << endl; exit(0); }
inline void no() { cout << "No" << endl; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); return a / gcd(a, b) * b; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { x = max(x, y); }
template <typename T> inline void amin(T &x, T y) { x = min(x, y); }
template <typename T> inline T exp(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
void solve() {
int n;
cin >> n;
string s;
cin >> s;
using P = pair<string, string>;
vector<map<P, int>> lst(n + 1);
rep(i, bit32(n)) {
int x = __builtin_popcount(i);
string a, b;
rep(j, n) {
((bit32(j) & i) ? a : b) += s[j];
}
lst[x][P(a, b)] += 1;
}
i64 ans = 0;
rep(i, bit32(n)) {
int x = __builtin_popcount(i);
string a, b;
rep(j, n) {
((bit32(j) & i) ? a : b) += s[n + j];
}
reverse(all(a));
reverse(all(b));
ans += lst[x][P(a, b)];
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
struct fastio {
fastio() {
ios::sync_with_stdio(false);
cout << setprecision(10) << fixed;
cin.tie(0);
}
};
fastio _fast_io;
const int N = 1e5 + 5;
int n, m, x, y, t;
int main() {
cin >> n >> m >> x >> y;
for (int i = 0; i < n; ++i) {
cin >> t;
x = max(x, t);
}
for (int i = 0; i < m; ++i) {
cin >> t;
y = min(y, t);
}
if (x < y)
cout << "No War" << endl;
else
cout << "War" << endl;
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string s;cin>>s;
auto pos = s.find("AC");
if(pos!=string::npos){
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | 0 |
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int n,q[40003];
long long ans,c[50];
int main(){
cin>>n;
char _a;
for(int i=1,_n=n+1;i<_n;i++){
cin>>_a;
switch(_a){
case 'R':
q[i]=1;
break;
case 'G':
q[i]=2;
break;
case 'B':
q[i]=4;
break;
}
c[q[i]]++;
}
ans=1ll*c[1]*c[2]*c[4];
for(int i=1,_m=n-1;i<_m;i++){
for(int j=i+1,_n=n+1;j<_n;j++){
ans-=((q[i]|q[j]|q[j+j-i])==7);
}
}
cout<<ans;
return 0;
}
| #include <bits/stdc++.h>
#define ALL(A) (A).begin(), (A).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); i++)
const ll MOD = 1e9 + 7;
const ll INF = -1 * ((1LL << 63) + 1);
const int inf = -1 * ((1 << 31) + 1);
using namespace std;
int N, M;
vector<int> A, B;
long long solve()
{
ll res = 1;
int biggerX_a = 0, biggerX_b = 0; // A,B でxより大きい数値の個数
for (int x = N * M; x >= 1; x--)
{
if (A[biggerX_a] > x)
return 0;
if (B[biggerX_b] > x)
return 0;
long long tmp = 1;
if (A[biggerX_a] == x && B[biggerX_b] == x)
{
tmp = 1;
++biggerX_a, ++biggerX_b;
}
else if (A[biggerX_a] == x)
{
tmp = biggerX_b;
++biggerX_a;
}
else if (B[biggerX_b] == x)
{
tmp = biggerX_a;
++biggerX_b;
}
else
{
tmp = biggerX_a * biggerX_b - (N * M - x);
if (tmp <= 0)
return 0;
}
res = (res * tmp) % MOD;
}
return res;
}
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
A.resize(N+1);
B.resize(M+1);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i];
sort(ALL(A), greater<int>());
sort(ALL(B), greater<int>());
cout << solve() << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string S; cin >> S;
int ok=0;
for (int i=0;i+1<S.size();++i)
if (S[i]=='A'&&S[i+1]=='C') ok=1;
cout << (ok?"Yes":"No") << '\n';
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int INF = 1e9;
int main(){
string s;cin >>s;
stack<char> st;
st.push(s[0]);
rep(i,s.size()-1){
char ch = '.';
if(st.size()){
ch = st.top();
//cout << ch << endl;
}
if(s[i+1]=='T'&&ch=='S'){
st.pop();
}else{
st.push(s[i+1]);
}
}
cout << st.size() <<endl;
} | 0 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
#include <queue>
#include <functional>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
int main() {
vector<int> v1(10),v2(10);
REP(i,10)
cin >> v1[i];
REP(i,10)
cin >> v2[i];
sort(ALL(v1), greater<int>());
sort(ALL(v2), greater<int>());
cout << v1[0]+v1[1]+v1[2] << " " << v2[0]+v2[1]+v2[2] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D;
cin >> A >> B >> C >> D;
int X = A + B, Y = C + D;
if (X > Y) cout << "Left" << endl;
else if (X == Y) cout << "Balanced" << endl;
else if (X < Y) cout << "Right" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[100];
int main(){
scanf("%s", s+1);
if(strlen(s+1) == 3) reverse(s+1, s+1+strlen(s+1));
printf("%s", s+1);
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const ll M = 1e9 + 7;
int main() {
string s;
cin >> s;
if (s.size() == 2) {
cout << s << endl;
return 0;
}
reverse(s.begin(),s.end());
cout << s << endl;
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cstdlib>
#include<cmath>
bool dfs(char board[8][8], bool v_used[], bool h_used[], bool dr_used[], bool dl_used[], int x, int y, int num) {
if (num == 8) return true;
for (int i = 0; i < 8; i++) {
if (h_used[i]) continue;
for (int j = 0; j < 8; j++) {
if (board[i][j] != 'Q') {
if (!v_used[j] && !h_used[i] && !dr_used[8 - j + i - 1] && !dl_used[i + j]) {
v_used[j] = h_used[i] = dr_used[8 - j + i - 1] = dl_used[i + j] = true;
board[i][j] = 'Q';
bool ret = dfs(board, v_used, h_used, dr_used, dl_used, i, j, num + 1);
if (ret) return true;
v_used[j] = h_used[i] = dr_used[8 - j + i - 1] = dl_used[i + j] = false;
board[i][j] = '.';
}
}
}
}
return false;
}
int main() {
int n;
bool v_used[8], h_used[8], dr_used[16], dl_used[16];
char board[8][8];
// ?????????????????????
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
board[i][j] = '.';
}
v_used[i] = h_used[i] = false;
}
for (int i = 0; i < 16; i++) {
dr_used[i] = dl_used[i] = false;
}
std::cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
std::cin >> x >> y;
board[x][y] = 'Q';
v_used[y] = true;
h_used[x] = true;
dr_used[8 - y + x - 1] = true;
dl_used[x + y] = true;
}
if (n == 8) {
for (int k = 0; k < 8; k++) {
for (int l = 0; l < 8; l++) {
std::cout << board[k][l];
}
std::cout << std::endl;
}
return 0;
}
for (int i = 0; i < 8; i++) {
if (h_used[i]) continue;
for (int j = 0; j < 8; j++) {
if (board[i][j] != 'Q') {
if (!v_used[j] && !h_used[i] && !dr_used[8 - j + i - 1] && !dl_used[i + j]) {
v_used[j] = h_used[i] = dr_used[8 - j + i - 1] = dl_used[i + j] = true;
board[i][j] = 'Q';
bool ret = dfs(board, v_used, h_used, dr_used, dl_used, i, j, n + 1);
if (ret) {
for (int k = 0; k < 8; k++) {
for (int l = 0; l < 8; l++) {
std::cout << board[k][l];
}
std::cout << std::endl;
}
return 0;
}
v_used[j] = h_used[i] = dr_used[8 - j + i - 1] = dl_used[i + j] = false;
board[i][j] = '.';
}
}
}
}
} | #include <iostream>
#include <vector>
#include <queue>
#include <utility>
using namespace std;
int lr[4]={1, 0, -1, 0};
int ud[4]={0, 1, 0, -1};
int main() {
int H, W;
cin >> H >> W;
vector<vector<int> > A(H, vector<int>(W));
for(int h=0; h<H; h++) {
for(int w=0; w<W; w++) {
cin >> A[h][w];
}
}
int dir=0;
queue<pair<int, int> > que;
que.push(make_pair(0, 0));
vector<vector<bool> > seen(H, vector<bool>(W, false));
vector<pair<pair<int, int>, pair<int, int> > > ans;
while(!que.empty()) {
pair<int, int> hw=que.front(); que.pop();
int curh=hw.first, curw=hw.second;
seen[curh][curw]=true;
bool flag=false;
if(A[curh][curw]%2) {
flag=true;
}
int tmpd=dir;
while(tmpd-dir<4) {
if(curh+ud[tmpd%4]<0 || curh+ud[tmpd%4]>=H || curw+lr[tmpd%4]<0 || curw+lr[tmpd%4]>=W) {
tmpd++;
continue;
}
if(seen[curh+ud[tmpd%4]][curw+lr[tmpd%4]]) {
tmpd++;
continue;
}
if(flag) {
A[curh+ud[tmpd%4]][curw+lr[tmpd%4]]++;
ans.push_back(make_pair(make_pair(curh, curw), make_pair(curh+ud[tmpd%4], curw+lr[tmpd%4])));
}
que.push(make_pair(curh+ud[tmpd%4], curw+lr[tmpd%4]));
dir = tmpd%4;
break;
}
}
cout << ans.size() << endl;
for(int i=0; i<ans.size(); i++) {
cout << ans[i].first.first+1 << " " << ans[i].first.second+1 << " " << ans[i].second.first+1 << " " << ans[i].second.second+1 << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string.h>
using namespace std;
char str[1000000];
int main() {
int ans, k, len, J, O, I;
int a;
//string str;
while(scanf("%s", str) != EOF) {
len = strlen(str);
J=0, O=0, I=0;
ans=0, k=0;
//cout << len << endl;
for(int i = 0 ; i < len ; i++) {
if(str[i] != 'J') continue;
if(str[i] == 'J') {
if(str[i] != '#') a = i;
while(str[a] == 'J') {
str[a] = '#';
a++;
J++;
}
if(str[a] == 'O') {
while(str[a] == 'O') {
a++;
O++;
}
if(str[a] == 'I') {
while(str[a] == 'I') {
a++;
I++;
}
}
}
}
//printf("J = %d, O = %d, I = %d\n", J, O, I);
if(O <= J && O <= I) k = min(J, min(O, I));
//if(J == O && O == I /*|| J <= O && O >= I*/) k = min(J, min(O, I));
//else J = 0; O = 0; I = 0;
ans = max(k, ans);
J = 0; O = 0; I = 0;
}
cout << ans << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main() {
string s;
int flag = -1, ans = 0;
int J = 0, O = 0, I = 0;
cin >> s;
for(int i=0; i<s.size(); i++) {
if( flag <= 0 && s[i] == 'J' ) {
flag = 0;
J++;
}
else if( flag == 0 && s[i] == 'O' ) {
flag = 1; O++;
}
else if( flag == 1 && s[i] == 'O' ) {
O++;
}
else if( flag == 1 && s[i] == 'I' ) {
flag = 2;
if( J >= O ) {
I++;
ans = max(1, ans);
}
else {
flag = -1;
J = O = I = 0;
}
}
else if( flag == 2 && s[i] == 'I' ) {
I++;
if( I >= O ) {
ans = max(ans, min(J, min(O, I)));
}
}
else {
if( s[i] == 'J' ) {
flag = 0;
J = 1; O = I = 0;
}
else {
flag = -1;
J = O = I = 0;
}
}
}
cout << ans << endl;
} | 1 |
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
int n, m, in[1001], data[1002001];
main(){
while(scanf("%d %d", &n, &m) && (n|m)){
in[0] = 0;
for(int i=1;i<=n;i++) scanf("%d", &in[i]);
for(int i=0;i<=n;i++) for(int j=0;j<=n;j++) data[i*(n+1)+j] = in[i] + in[j];
int size = (n+1)*(n+1), ans = 0;
sort(data, data+size);
for(int i=0;i<size;i++){
int l = 0, r = size-1;
while(r-l>1){
int med = (l+r) / 2;
if(data[i] + data[med] <= m) l = med;
else r = med;
}
if(data[i] + data[l] <= m) ans = max(ans, data[i] + data[l]);
}
printf("%d\n", ans);
}
} | #include<iostream>
#include<vector>
#include<map>
#include<utility>
#include<algorithm>
#include<queue>
#include<stack>
#include<string>
#include<stdlib.h>
#include<stdio.h>
#include<cmath>
#include<cstdlib>
#include<typeinfo>
#include<sstream>
#include<list>
#include<set>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define fori(i,k,n) for(int i=k;i<(int)n;i++)
using namespace std;
int in()
{
int x;cin>>x;
return x;
}
int stringInt(string a)
{
return atoi(a.c_str());
}
string intString(int a)
{
stringstream ss;
ss<<a;
return ss.str();
}
vector<int> SieveOfEratosthenes(int x)
{
vector<int> a;
vector<int> b(x+1,0);
for(int i=2;i<=x;i++)
{
if(b[i]==0)
{
a.push_back(i);
for(int l=i;l<=x;l+=i)
{
b[l]=1;
}
}
}
return a;
}
int main ()
{
int n,m;
while(cin>>n>>m&&n&&m)
{
vector<long long > a,b;
b.push_back(0);
rep(i,n)
{
b.push_back(in());
}
rep(i,n+1)
{
rep(l,n+1)
{
a.push_back(b[i]+b[l]);
}
}
long long ans = 0;
sort(a.begin(),a.end());
rep(i,a.size())
{
vector<long long>::iterator t=upper_bound(a.begin(),a.end(),m-a[i]);
if(t==a.begin())continue;
t--;
ans=max(ans,*t+a[i]);
}
cout<<ans<<endl;
}
} | 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <numeric>
#include <boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>
#include <vector>
#include <list>
using namespace std;
using namespace boost;
int main(int argc, char* argv[])
{
using sprtr = char_separator<char>;
using tknzr = tokenizer<sprtr>;
sprtr sep(" ", "", keep_empty_tokens);
int f, mf, mo;
string line;
while(1) {
int n, m;
{
getline(cin, line);
tknzr tkns(line, sep);
auto it = tkns.begin();
n = lexical_cast<int>(*it++);
m = lexical_cast<int>(*it);
}
if( n == 0 && m == 0 ) {
break;
}
list<int> ps;
{
getline(cin, line);
tknzr tkns(line, sep);
for( auto p : tkns ) {
//cout << p << endl;
ps.push_back(lexical_cast<int>(p));
}
}
ps.sort(greater<int>());
int div = n / m;
int mod = n % m;
int sum = 0;
auto it = ps.begin();
for( int i = 0; i < div; i++ ) {
for( int j = 0; j < m; j++ ) {
auto p = *it++;
if( j == m-1 ) continue;
sum += p;
}
}
if( mod ) {
for( int i = 0; i < mod; i++ ) {
auto p = *it++;
sum += p;
}
}
cout << sum << endl;
ps.clear();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n) - 1; i >= 0; i--)
int n, m;
int p[1010];
int main()
{
while (cin >> n >> m, n){
rep(i, n) cin >> p[i];
sort(p, p + n, greater<int>());
int res = 0;
rep(i, n) res += p[i];
for (int i = m - 1; i < n; i += m){
res -= p[i];
}
cout << res << endl;
}
} | 1 |
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define F first
#define S second
#define EB emplace_back
#define PB push_back
#define ld long double
#define lb lower_bound
#define ub upper_bound
#define ar array
#define sz(x) (int)x.size()
#define bit(x) __builtin_popcount(x)
#define all(x) (x).begin(), (x).end()
#define FOR(c,l,r) for(int c=(l);c<=(r);c++)
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }
using ll = long long;
//#define int ll
const int N = 2e6 + 7;
const int MOD = 1e9 + 7;
const int inf = 2e9 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = { 0, 1, 0, -1, 1, -1, 1, -1};
const char dt[] = {'U', 'R', 'D', 'L'};
map <int, int> mp;
int ok(int n) {
while (n) {
if (mp[n % 10]) return false;
n /= 10;
} return true;
}
void solve() {
int n, k;
cin >> n >> k;
for (int i = 0; i < k; i ++) {
int x;
cin >> x;
mp[x] = 1;
}
while (!ok(n)) {
n ++;
}
cout << n;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
//cin >> tt;
while (tt --){
solve();
cout << '\n';
}
}
| #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
const int MOD = 1000000007;
using namespace std;
void solve(void)
{
ll n;
cin >> n;
n *= 2;
vector<int> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
int ans = 0;
for (int i = 0; i < n; i += 2)
{
ans += min(v[i], v[i + 1]);
}
cout << ans << endl;
}
int main(void)
{
solve();
} | 0 |
// 去吧！皮卡丘! 把AC带回来！
// へ ／|
// /＼7 ∠＿/
// / │ ／ ／ AC AC AC AC
// │ Z ＿,＜ ／ /`ヽ AC AC AC AC
// │ ヽ / 〉 AC AC AC AC
// Y ` / / / AC AC AC AC
// 亻● . ● 〈 / / AC AC AC AC
// () へ | ＼〈 AC AC AC AC
// >- ._ ィ │ ／／ AC AC AC AC
// / へ / /＜| ＼＼ AC AC AC AC
// ヽ_/ (_／ │／／ AC AC AC AC
// 7 |／ AC AC AC AC
// ＞―r￣￣`-―＿/ AC AC AC AC
//**************************************Accepted*****************************************//
#include<bits/stdc++.h>
#define all(x) x.begin(),x.end()
#define pb push_back
#define mp make_pair
#define Unique(x) x.erase(unique(all(x)),x.end());
#define CIN_FILE "input.txt"
#define COUT_FILE "output.txt"
#define Pig (OO)
using namespace std;
const int dx[]={-1,0,1,0};
const int dy[]={0,-1,0,1};
const int Days[]={-1,31,28,31,30,31,30,31,31,30,31,30,31};
inline int read()
{
#define gc getchar
int ans=0;
bool f=1;
char ch=gc();
while(!isdigit(ch))f^=ch=='-',ch=gc();
while(isdigit(ch))ans=((ans<<2)+ans<<1)+(ch^48),ch=gc();
return f?ans:-ans;
#undef gc
}
typedef long long ll;
int n,m;
vector<int> v[1010];
int vis[1010];
vector<int> path;
int indeg[1010],outdeg[1010];
bool edges[1010][1010];
bool OK()
{
memset(indeg,0,sizeof(indeg));
memset(outdeg,0,sizeof(outdeg));
for(int i=0;i<path.size();i++)for(int j=0;j<path.size();j++)
{
if(indeg[path[i]]>1||outdeg[path[j]]>1)return 0;
if(edges[path[i]][path[j]])indeg[path[i]]++,outdeg[path[j]]++;
}
for(int i=0;i<path.size();i++)if(indeg[path[i]]!=1||outdeg[path[i]]!=1)return 0;
return 1;
}
void pprint()
{
if(!OK())return;
cout<<path.size()<<endl;for(int i=0;i<path.size();i++)cout<<path[i]<<endl;
exit(0);
}
void DFS(int x)
{
path.pb(x);
vis[x]=2;
for(int i=0;i<v[x].size();i++)
{
if(vis[v[x][i]]==0)DFS(v[x][i]);
if(vis[v[x][i]]==2)pprint();
}
path.pop_back();
vis[x]=1;
}
int main(int argc, char const *argv[])
{
ios::sync_with_stdio(false);
cin>>n>>m;
for(int i=0;i<m;i++)
{
int x,y;
cin>>x>>y;
v[x].pb(y);
edges[x][y]=1;
}
for(int i=1;i<=n;i++)
{
memset(vis,0,sizeof(vis));
path.clear();
if(!vis[i])DFS(i);
}
cout<<-1;
//printf("Time used = %.12f",(double)(clock())/CLOCKS_PER_SEC);
return 0;
}
/* GOD BLESS */
| #include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
std::vector<std::vector<int>> StronglyConnectedComponents(
const std::vector<std::vector<int>>& graph) {
int n = graph.size();
std::vector<int> nodes;
std::vector<bool> visited(n);
std::function<void(int)> dfs = [&](int u) {
visited[u] = true;
for (int v : graph[u]) {
if (!visited[v]) {
dfs(v);
}
}
nodes.push_back(u);
};
for (int u = 0; u < n; ++u) {
if (!visited[u]) dfs(u);
}
std::vector<std::vector<int>> rgraph(n);
for (int u = 0; u < n; ++u) {
for (int v : graph[u]) {
rgraph[v].push_back(u);
}
}
std::vector<bool> rvisited(n);
std::vector<std::vector<int>> sccs;
std::function<void(std::vector<int>&, int)> rdfs = [&](std::vector<int>& scc,
int u) {
rvisited[u] = true;
scc.push_back(u);
for (int v : rgraph[u]) {
if (!rvisited[v]) {
rdfs(scc, v);
}
}
};
for (int i = n - 1; i >= 0; --i) {
int u = nodes[i];
if (!rvisited[u]) {
std::vector<int> scc;
rdfs(scc, u);
sccs.push_back(scc);
}
}
return sccs;
}
int main() {
in(int, n, m);
vector<vector<int>> graph(n);
rep(i, m) {
in(int, a, b);
graph[a - 1].push_back(b - 1);
}
vector<vector<int>> sccs = StronglyConnectedComponents(graph);
for (const vector<int>& scc : sccs) {
if (scc.size() == 1) continue;
set<int> scc_nodes(all(scc));
int node = scc[0];
map<int, int> next;
map<int, int> prev;
for (int n : scc_nodes) dbg(n);
while (true) {
for (int child : graph[node]) {
if (scc_nodes.count(child) == 0) continue;
next[node] = child;
prev[child] = node;
if (next.count(child) != 0) goto out;
node = child;
break;
}
}
out:
node = scc[0];
if (prev.count(node) == 0) {
while (true) {
int child = next[node];
next.erase(node);
if (prev[child] != node) break;
prev.erase(child);
node = child;
}
}
rep(u, n) for (int v : graph[u]) {
if (next.count(u) > 0 && next.count(v) > 0) {
int c = next[u];
while (c != v) {
int nc = next[c];
next.erase(c);
prev.erase(c);
c = nc;
}
next[u] = v;
prev[v] = u;
}
}
vector<int> v;
int u = next.begin()->first;
do {
v.push_back(u);
u = next[u];
} while (u != next.begin()->first);
out(v.size());
for (int u : v) out(u + 1);
return 0;
}
out(-1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define sz(x) (int) x.size()
#define pb push_back
#define endl '\n'
#define snd second
#define fst first
#define fastio cin.tie(NULL),cout.sync_with_stdio(true)
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector <int> vi;
typedef pair <int, int> ii;
const ll mod = 998244353;
//const ll mod = 1e9 + 7;
const ll INF = (1LL<<50);
const double EPSILON = 0.001;
const int N = 200005;
ll mul(ll a, ll b){
return a*b%mod;
}
ll add(ll a, ll b){
a += b;
if(a >= mod)
a-=mod;
return a;
}
ll expo(ll a, ll b){
ll r = 1;
for(;b; b >>= 1, a = mul(a,a))
if(b&1)
r = mul(r, a);
return r;
}
ll fact[N], ifact[N];
void init(){
fact[0] = 1;
for(ll i = 1; i < N; i++)
fact[i] = mul(i, fact[i-1]);
ifact[N-1] = expo(fact[N-1], mod-2);
for(ll i = N-2; i >= 0; i--)
ifact[i] = mul(ifact[i+1], i+1);
}
ll ncr(ll n, ll r){
if(n < r)return 0;
return mul(fact[n], mul(ifact[r], ifact[n-r]));
}
/*
from n total blocks, (n-1) is the total of adj pairs.
assuming we want to make only k pairs to have the same color
doesn't matter how those pairs are distributed , the ways to
color them always follow that formula : C(n-1,k) * m * 1^(k) * (m-1)^(n-1-k)
so the final answer is:
i:(0,k) Σ C(n-1,i) * m * 1^i * (m-1) ^(n-1-i)
*/
int main(){
fastio;
init();
int n,m,k,ans = 0;
cin >> n >> m >> k;
for(int i = 0; i <= k; i++)
ans = add(ans, mul(ncr(n-1, i), mul(m, expo(m-1, n-1-i))));
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
const int mod = 998244353;
int n;
int m;
int k;
long long inv[N];
long long fac[N];
long long finv[N];
void cominit(){
fac[0] = fac[1] =1;
finv[0] = finv[1] =1;
inv[1] = 1;
for(int i = 2; i < N; 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 nCr(long long n , long long r){
if(n < r)
return 0;
if(n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % mod) %mod;
}
int fastP(int b, int e){
if(!e)
return 1;
if(e & 1)
return b * 1ll * fastP(b * 1ll * b % mod, e >> 1) % mod;
return fastP(b * 1ll * b % mod, e >> 1) % mod;
}
void mul(long long & a , long long b){
a *= b;
a %= mod;
}
int main(){
scanf("%d%d%d" , &n , &m , &k);
cominit();
long long ways = 0;
for(int i = 0; i <= k; i++){
long long sofar = 1;
mul(sofar , m);
mul(sofar , fastP(m - 1 , n - 1 - i));
mul(sofar , nCr(n - 1 , i));
ways += sofar;
ways %= mod;
}
printf("%lld\n" , ways);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,l;
cin >> n >> l;
int a[n];
int all = 0;
for(int i = 1; i <= n; i++){
a[i] = l + i - 1;
all += a[i];
}
int minu = 0,maxmin = 2000000;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
if(j != i){
minu += a[j];
}//if
}//for
if(abs(minu - all) < abs(maxmin - all)){
maxmin = minu;
}
minu = 0;
}
cout << maxmin << endl;
} | /*16D8103008D 西村 悠輝 ALDS10C*/
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string X, Y;
int v[1001][1001];
int dp(string X, string Y) {
int n = X.size();
int m = Y.size();
for (int i = 0; i <= n; i++) {
v[i][0] = i; ///０のテーブル
for (int j = 0; j <= m; j++) {
v[0][j] = j;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (X[i-1] == Y[j-1]) {
v[i][j]= v[i-1][j-1];
}
else {
int y = min(v[i][j - 1] + 1, v[i - 1][j] + 1);
if (y > v[i - 1][j - 1] + 1) {
v[i][j] = v[i - 1][j - 1] + 1;
}else{
v[i][j] = y;
}
}
}
}
return v[n][m];
}
int main(void)
{
cin >> X >> Y;
int ans = dp(X, Y);
cout << ans << endl;
}
/*
acac
acm
2
*/
| 0 |
#include <bits/stdc++.h>
/// ____ ____ ____ ____ ____
/// ||a |||t |||o |||d |||o ||
/// ||__|||__|||__|||__|||__||
/// |/__\|/__\|/__\|/__\|/__\|
///
using namespace std;
const int N_MAX = 302;
const int M_MAX = 302;
int n, m;
int a[N_MAX][M_MAX];
bool del[N_MAX];
int pos[N_MAX];
int cnt[M_MAX];
queue <int> q;
bool f (int mx)
{
for(int i = 1; i <= m; i++)
{
del[i] = false;
cnt[i] = 0;
}
while(!q.empty())
q.pop();
for(int i = 1; i <= n; i++)
{
pos[i] = 1;
if(++cnt[a[i][1]] == mx + 1)
q.push(a[i][1]);
}
while(!q.empty())
{
int f = q.front();
q.pop();
del[f] = true;
for(int i = 1; i <= n; i++)
if(del[a[i][pos[i]]] == true)
{
while(pos[i] <= m && del[a[i][pos[i]]] == true)
pos[i]++;
if(pos[i] == m + 1)
return false;
if(++cnt[a[i][pos[i]]] == mx + 1)
q.push(a[i][pos[i]]);
}
}
return true;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
cin >> a[i][j];
int l = 1, r = n;
while(l < r)
{
int mid = ((l + r) >> 1);
if(f(mid) == true)
r = mid;
else
l = mid + 1;
}
cout << l << "\n";
return 0;
}
| #include <cstdio> // printf(), scanf()
#include <vector>
#include <algorithm> // sort()
using namespace std;
static const int MAX_E = 100000;
class disjointSet
{
public:
vector<int> rank;
vector<int> par;
disjointSet() {}
disjointSet(int size)
{
rank.resize(size, 0);
par.resize(size, 0);
for (int i = 0; i < size; ++i)
{
par[i] = i;
rank[i] = 0;
}
}
int find(int x)
{
if (x != par[x])
par[x] = find(par[x]);
return par[x];
}
void unite(int x, int y)
{
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
par[x] = y;
else
{
par[y] = x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool same(int x, int y)
{
return find(x) == find(y);
}
};
struct edge
{
int from, to;
int cost;
};
edge es[MAX_E];
int V, E;
bool
cmp_func(const edge &e1, const edge &e2)
{
return e1.cost < e2.cost;
}
int
kruskal()
{
sort(es, es + E, cmp_func);
disjointSet dset = disjointSet(V);
int res = 0;
for (int i = 0; i < E; ++i)
{
edge e = es[i];
if (!dset.same(e.from, e.to))
{
dset.unite(e.from, e.to);
res += e.cost;
}
}
return res;
}
int
main(int argc, char** argv)
{
edge e;
int s, t, w;
int i;
scanf("%d %d", &V, &E);
for (i = 0; i < E; ++i)
{
scanf("%d %d %d", &s, &t, &w);
e.from = s;
e.to = t;
e.cost = w;
es[i] = e;
}
printf("%d\n", kruskal());
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define rep(i, n) repl(i, 0, n)
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
const ll MOD = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 4e18 + 10;
const int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int h, n, k;
cin >> h >> n >> k;
vector<vector<ll>> table(n, vector<ll>(n));
rep(bit, 1 << (n - 1)) {
vector<int> a(n - 1);
int p = bit;
rep(i, n - 1) {
if (p & 1) a[i] = 1;
p >>= 1;
}
bool flag = 0;
rep(i, n - 2) {
if (a[i] + a[i + 1] == 2) flag = 1;
}
if (flag) continue;
vector<int> T(n);
rep(i, n) T[i] = i;
rep(i, n - 1) {
if (a[i] == 1) swap(T[i], T[i + 1]);
}
rep(i, n) table[i][T[i]]++;
}
vector<vector<ll>> dp(h + 1, vector<ll>(n));
dp[0][0] = 1;
rep(i, h) rep(j, n) rep(k, n) dp[i + 1][k] = (dp[i + 1][k] + dp[i][j] * table[j][k] % MOD) % MOD;
cout << dp[h][k - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(n);i++)
#define N 105
#define INF 1000000000
typedef long long ll;
#define ALL(v) (v).begin(),(v).end()
#define SZ(x) int(x.size())
#define IN(a) cin>>(a)
#define OUT(a) cout<<(a)<<endl
typedef pair<int,int> P;
const int MAX = 100005;
const int MOD = 1000000007;
int dpo[10];
int dpx[10];
ll dp[105][10];
int w;
int d(int x){
if(x<=0||x>w)return 1;
else return (dpo[x]+dpx[x]);
}
int main(){
int h,k;
cin>>h>>w>>k;
dpo[1]=1;dpx[1]=0;
for(int i=1;i<w;i++){
dpo[i+1]=dpo[i]+dpx[i];
dpx[i+1]=dpo[i];
}
dp[0][1]=1;
REP(i,h){
for(int j=1;j<=w;j++){
dp[i+1][j]+=(ll)dp[i][j]*d(j-1)*d(w-j);
//cout<<dp[i][j]<<" "<<d(j-1)<<" "<<d(w-j);
dp[i+1][j]%=MOD;
dp[i+1][j]+=dp[i][j+1]*d(w-j-1)*d(j-1);
dp[i+1][j]+=dp[i][j-1]*d(w-j)*d(j-2);
dp[i+1][j]%=MOD;
//OUT(dp[i+1][j]);
}
}
OUT(dp[h][k]);
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
if (N == 1) {
cout << "Hello World" << endl;
return 0;
}
int A, B;
cin >> A >> B;
cout << A + B << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for(int i= 0; i < (n); i++)
using ll= long long int;
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; }
ll mod= 1e9 + 7;
int main(){
int g;
cin >>g;
int a,b;
cin >>a >>b;
if(g==1){cout << "Hello World" << endl;}else{cout << a+b << endl;}
} | 1 |
//ヘッダー
#include<bits/stdc++.h>
using namespace std;
//型定義
typedef long long ll;
//定数
const ll INF=1e+17;
const int MOD=1e+9+7;
//REPマクロ
#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 REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)
//vectorの扱い
#define ALL(x) (x).begin(),(x).end() //sortなどの引数省略
#define SIZE(x) ((ll)(x).size()) //size
#define MAX(x) *max_element(ALL(x)) //最大値
#define MIN(x) *min_element(ALL(x)) //最小値
//グローバル変数
//ライブラリ挿入
int main(){
int N;
cin >> N;
vector<ll> A(N);
REP(i,N) cin >> A[i];
vector<vector<ll>> dp(N+1,vector<ll>(2,0));
dp[0][0]=0;
dp[0][1]=0;
dp[1][0]=0;
dp[1][1]=A[0];
REP2(i,1,N){
if(i%2==1){
dp[i+1][0]=max(dp[i][1],dp[i-1][0]+A[i]);
}else{
dp[i+1][0]=max(dp[i][0],dp[i-1][0]+A[i]);
dp[i+1][1]=dp[i-1][1]+A[i];
}
}
cout<<dp[N][0]<<endl;
} | #include<bits/stdc++.h>
using namespace std;
#define ft ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
const int N=3e5+2;
ll M=1e9+7;
ll a[N];
int main()
{
ft
ll i,j,n,s=0,l,r,m;
cin>>n;
for(i=0;i<n;i++)
{
cin>>a[i];
}
for(i=0,m=1;i<61;i++,m*=2)
{
l=r=0;
for(j=0;j<n;j++)
{
(a[j]%2)? l++: r++;
a[j]/=2;
}
s+=(((l*r)%M)*(m%M))%M;
s%=M;
}
cout<<s<<"\n";
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int64_t ans=1;
int m,j,k,y,mod=1e9+7;
bool f;
cin>>m;
vector<int> p={2};
for(j=3;j<=m;j+=2){
f=true;
for(k=0;k<(int)p.size();k++){
if(j%p.at(k)==0){
f=false;
break;
}
}
if(f==true) p.push_back(j);
}
int l=p.size();
vector<int> x(l);
for(j=2;j<=m;j++){
y=j;
for(k=0;k<l;k++){
while(y%p.at(k)==0){
x.at(k)++;
y/=p.at(k);
}
if(y==1) break;
}
}
for(auto z:x) ans=ans*(z+1)%mod;
cout<<ans<<endl;
} | #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;
}
| 1 |
#include<iostream>
using namespace std;
int dp[31] ={1,2,4},step;
int main(){
for(int i=3;i<31;i++){
dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
}
while(cin>>step,step){
cout<<(dp[step-1])/3650+1<<endl;
}
return 0;
} | #include<iostream>
using namespace std;
int main(){
int ans[31]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,3,6,10,19,34,62,113,207,381,701,1288,2369,4357,8014,14740};
while(1){
cin>>ans[0];
if(!ans[0])
return 0;
cout<<ans[ans[0]]<<endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
void computeLPSArray(string pattern, int m, int lps[]){
int len=0;
lps[0]=0; //lps[0] is always 0
int i=1;
while(i<m){
if(pattern[i]==pattern[len]){
len++;
lps[i]=len;
i++;
}else{
if(len!=0)
len=lps[len-1];
else{
lps[i]=0;
i++;
}
}
}
}
void kmpSearch(string str,string pattern){
int m=pattern.length();
int n=str.length();
int lps[m]; //longest prefix suffix array
computeLPSArray(pattern,m,lps);
int i=0; //text
int j=0; //pattern
bool found=0;
while(i<n){
if(pattern[j]==str[i]){
i++;
j++;
}
if(j==m){
j=lps[j-1];
found=1;
break;
}else if(i<n && pattern[j]!=str[i]){
if(j!=0) j=lps[j-1];
else i=i+1;
}
}
if(!found)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
int main(){
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
string str,pattern;
while(cin>>str){
pattern="AC";
kmpSearch(str,pattern);
}
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll (i) = 0; (i) < (n); (i)++)
#define rep1(i, n) for(ll (i) = 1; (i) <= (n); (i)++)
#define rrep(i, n) for(ll (i) = (n) - 1; (i) >= 0; (i)--)
#define rrep1(i, n) for(ll (i) = (n); (i) >= 1; (i)--)
const ll INF = 1145141919;
const ll MOD = 1000000007;
template<class T> void chmax(T &a, const T &b){if(a < b){a = b;}}
template<class T> void chmin(T &a, const T &b){if(a > b){a = b;}}
int main(){
string s, ans = "No";
cin >> s;
rep(i, s.size() - 1)if(s[i] == 'A' && s[i + 1] == 'C')ans = "Yes";
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define yn(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YN(ans) if(ans)printf("YES\n");else printf("NO\n")
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
//入力系
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
//出力系
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
//デバッグ系
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
int main(){
struct dice{int u,e,w,n,s,d;
void rotate(char c){
int temp=u;
if(c=='E'){u=w;w=d;d=e;e=temp;}
else if(c=='W'){u=e;e=d;d=w;w=temp;}
else if(c=='N'){u=s;s=d;d=n;n=temp;}
else if(c=='S'){u=n;n=d;d=s;s=temp;}
}
bool hikaku(dice q){
int counter=0;
if(u==q.u)counter++;
if(s==q.s)counter++;
if(e==q.e)counter++;
if(w==q.w)counter++;
if(n==q.n)counter++;
if(d==q.d)counter++;
if(counter==6)return true;else return false;
}
};
int n;
in(n);
vector<dice> vec(n);
rep(i,n){
in(vec[i].u,vec[i].s,vec[i].e,vec[i].w,vec[i].n,vec[i].d);
}
string s="NNNNENNNN";
for(int j=0;j<n-1;j++){
for(int k=j+1;k<n;k++){
dice a=vec[j];
dice b=vec[k];
rep(i,9){
if(a.s==b.s)break;
b.rotate(s[i]);
}
int counter=0;
while(!a.hikaku(b)){
b.rotate('E');
counter++;
if(counter>=5){
goto skip;
}
}
out("No");
return 0;
skip: ;
}
}
out("Yes");
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll count ( ll n)
{
ll ans =0;
while( n%2==0)
{
n= n/2;
ans++;
}
return ans;
}
int main()
{
ll n;
cin>>n;
ll a[n];
ll ans = INT_MAX;
for(int i=0;i<n;i++)
{
cin>>a[i];
ans = min(ans , count(a[i]));
}
cout<<ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int testcase=1;
for(int p=0;p<testcase;p++){
ll n=0,x=0;
cin>>n>>x;
ll array[n]={0};
ll totalsum=0;
for(int i=0;i<n;i++){
cin>>array[i];
totalsum+=array[i];
}
if(totalsum<x){
cout<<n-1;
}
else if(totalsum==x)
cout<<n;
else
{
sort(array,array+n);
ll counter=0;
ll sum=x;
ll i=0;
while(sum>=0){
// cout<<array[i];
sum-=array[i];
if(sum<0)
break;
i++;
counter++;
}
cout<<counter;
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (int64_t)(n); i++)
#define rrep(i, n) for (int64_t i = (n)-1; i >= 0; i--)
#define rirep(i, n) for (int64_t i = n; i >= 0; i--)
int main() {
int N;
int64_t x;
cin >> N >> x;
vector<int64_t> a(N);
rep(i, N) { cin >> a[i]; }
sort(a.begin(), a.end());
rep(i, N - 1) { a[i + 1] += a[i]; }
auto p = lower_bound(a.begin(), a.end(), x);
if (p == a.end()) {
cout << N - 1 << endl;
} else if (*p > x) {
cout << p - a.begin() << endl;
} else {
cout << p - a.begin() + 1 << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int a;
int dp[n];
int ans=0;
for(int i=0;i<n;i++)dp[i]=1e9;
for(int i=0;i<n;i++){
cin >> a;
a *= (-1);
*upper_bound(dp,dp+n,a)=a;
}
cout << lower_bound(dp,dp+n,1e9)-dp;
} | #include <bits/stdc++.h>
#include<math.h>
using namespace std;
using ll = long long;
int main(){
int h1, m1, h2, m2 ,k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int h3 = h2 -1;
int m3 = m2 + 60;
int a = (h3-h1)*60+(m3-m1);
cout << max(a-k, 0) << endl;
return 0;
} | 0 |
#include<iostream>
#include<vector>
#include<string>
#include<cmath>
#include<algorithm>
#include <numeric>
#include<map>
#include<unordered_map>
#include <queue>
using namespace std;
using ll=long long;
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(itr,mp) for(auto itr=mp.begin();itr!=mp.end();itr++)
#define ALL(a) (a).begin(),(a).end()
int main(){
string s;
cin >> s;
rep(i, s.size()-8)cout << s[i];
}
|
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << endl;
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int a, b ,c, d;
cin >> a >> b >> c >> d;
print(min(a, b) + min(c, d));
}
| 0 |
// ABC_104_B
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin >> s;
bool flag1 = false, flag2 = false, flag3 = false;
if (s[0] == 'A') flag1 = true;
int counter_1 = 0;
for (int i = 2; i < s.size()-1; ++i) {
if (s[i] == 'C') ++counter_1;
else continue;
}
if (counter_1 == 1) flag2 = true;
int counter_2 = 0;
for (int i = 0; i < s.size(); ++i) {
if (isupper(s[i])) ++counter_2;
else continue;
}
if (counter_2 == 2) flag3 = true;
if (flag1 && flag2 && flag3) cout << "AC" << "\n";
else cout << "WA" << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define forn(i, k, n) for (int i = k+1; i < int(n); i++)
typedef long long LL;
typedef pair<int, int> PII;
int digit(long n){
int dig = 1;
while(n / 10 > 0){
n /= 10;
dig++;
}
return dig;
}
long search_mul(long small, long big, long n){
long a,b;
int i;
for(i = small + 1; i < big; i++){
if(n % i == 0){
a = i;
b = n/a;
if(n % (a * small) == 0 && a*small < n/(a*small)){
a = a * small;
b = n/a;
//cout << a << " * " << b << endl;
return search_mul(a,b,n);
}
//cout << a << " * " << b << endl;
//return min(digit(b), search_mul(a,b,n));
return search_mul(a,b,n);
}
}
//cout << small << " * " << big << " ,ans :";
return big;
}
void f(long n) {
int ans;
long temp = sqrt(n)+1;
long ret;
ret = search_mul(1,temp,n);
if(ret == temp)
ans = digit(n);
else
ans = digit(ret);
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long n;
cin >> n;
f(n);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long k; //k=123
cin>>k;
long a,b,c;
a=k/50+50; //要特别处理的数的大小 a=123/50+50 = 2+50=52
b=k%50; //要特别处理的数的个数 b=123%50=23
c=a-b-1; //正常相等的数值 c=52-23-1=28
int x[55]={0};
int xx=0;
cout<<50<<endl;
for(int i=0;i<50;i++)
{
if(i<b)
{
if(i==0)
cout<<a;
else
cout<<" "<<a;
x[xx]=a;
}
else
{
if(i==0)
cout<<c;
else
cout<<" "<<c;
x[xx]=c;
}
xx++;
}
cout<<endl;
/* int mmax;
int index=0;
cout<<"变化之后"<<endl;
int s=123;
while(s--)
{
mmax=-1;
for(int j=0;j<50;j++)
{
if(x[j]>mmax)
{
mmax=x[j];
index=j;
}
}
for(int j=0;j<50;j++)
{
if(index==j)
{
x[index]-=50;
}
else
{
x[j]++;
}
}
}
for(int i=0;i<xx;i++)
{
cout<<x[i]<<" ";
} */
return 0;
}// 23+28=51;23个2加上22个1 55， 27个51 （23次）
//27
//23个52 第22次后 还剩一个52+22，前面的都 -50+21=23 之后的 +22 = 50
//第23次后 前23个都变成了 24， 后27个变成了 51
//第27次后 后27个51 变成了 51-50+26 =27 前23个 24+27=51
//所以经过50次之后 前23个52变成了51 ，后27个28 变成了27
//第100次后 前23个变成了50，后27个变成26
//第23次后 前23个变成了22，后27变成了49
| #include <bits/stdc++.h>
using namespace std;
long long K;
int main()
{
cin >> K;
cout << 50 << endl;
for (int i=0; i<=50; i++)
{
if (50-i != K%50) cout << K/50 + i << " ";
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define printVec(v) printf("{"); for (const auto& i : v) { std::cout << i << ", "; } printf("}\n");
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 namespace std;
using P = pair<int,int>;
using ll = long long;
const ll INF = 1LL<<60;
const double PI = 3.1415926535897932;
const int MOD = 1e9 + 7;
//cin.tie(0);ios::sync_with_stdio(false);
int main() {
int n;
cin >> n;
vector<int> a;
a.push_back(0);
rep (i, n) {
int x; cin >> x;
a.push_back(x);
}
a.push_back(0);
ll sum = 0;
for (int i = 1; i < n + 2; i++) {
sum += abs(a[i] - a[i - 1]);
//printf("abs(a[%d] - a[%d]) = %d\n", i, i - 1, abs(a[i] - a[i - 1]));
}
for (int i = 1; i < n + 1; i++) {
ll tmp = sum;
tmp -= abs(a[i] - a[i - 1]);
tmp -= abs(a[i + 1] - a[i]);
tmp += abs(a[i - 1] - a[i + 1]);
cout << tmp << endl;
}
//printVec(a);
//printf("sum = %d\n", sum);
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
class UnionFind {
public:
vector <ll> par;
vector <ll> siz;
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)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
int main() {
ll n;
cin >> n;
vector<ll> z(n);
for (int i = 0; i < n; i++) {
cin >> z[i];
}
ll ans = 0;
ll fl = 0;
if (z[0] > 0)fl = -1;
for (int i = 1; i < n; i++) {
if (z[i - 1] + 1 < z[i])fl = -1;
}
if (fl == -1)cout << -1 << endl;
else {
ans += z[n - 1];
for (int i = n-2; i > 0; i--) {
if (z[i + 1] <= z[i])ans += z[i];
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
vector<ll>vec(3);
ll a=0;
for(ll i=0;i<3;i++){
cin>>vec.at(i);
a+=vec.at(i);
}
sort(vec.begin(),vec.end());
cout<<a-vec.at(2)<<endl;
return 0;
}
| #include<iostream>
#include<math.h>
using namespace std;
int main(){
int a,b,c,e=0,z,d,f,g;
cin>>a>>b>>c;
z=min((a+b),(b+c));
z=min(z,(c+a));
cout<<z;
return 0;
}
| 1 |
#include <iostream>
#include <time.h>
#include <algorithm>
#include <stdio.h>
#include<string.h>
typedef long long LL;
using namespace std;
const int times = 20;
LL fac[1001];
int cnt;
LL mul(LL a, LL b, LL mod)
{
LL ans = 0;
while (b)
{
if (b & 1)
{
ans = (ans + a) % mod;
}
a = (a << 1) % mod;
b >>= 1;
}
return ans;
}
LL pow(LL a, LL b, LL mod)
{
LL ans = 1;
while (b)
{
if (b & 1)
{
ans = mul(ans, a, mod);
}
b >>= 1;
a = mul(a, a, mod);
}
return ans;
}
bool witness(LL a, LL n)
{
LL temp = n - 1;
int j = 0;
while (temp % 2 == 0)
{ // 其实就是得到 m
j++;
temp /= 2;
}
LL x = pow(a, temp, n);
if (x == 1 || x == n - 1)
{ // 判断a^m
return true;
}
while (j--)
{
x = mul(x, x, n); // 进一步判断 a^(2m) a^(4m) ...
if (x == n - 1)
return true;
}
return false;
}
bool miller_rabin(LL n)
{
if (n == 2)
{ // 如果是2肯定是素数
return true;
}
if (n < 2 || n % 2 == 0)
{ //如果小于2或者是大于2的偶数肯定不是素数
return false;
}
for (int i = 0; i < times; i++)
{ //随机化检验
LL a = rand() % (n - 1) + 1;
if (!witness(a, n))
return false;
}
return true;
}
LL gcd(LL a, LL b)
{ // 这里的gcd和一般的gcd不一样
if (a == 0)
{ // pollard_rho的需要
return 1;
}
if (a < 0)
{ // 可能有负数
return gcd(-a, b);
}
while (b)
{
LL t = a % b;
a = b;
b = t;
}
return a;
}
LL pollard_rho(LL n, LL c)
{ // 找因子
LL i = 1, k = 2; // 用来判断是否成环
LL xx = rand() % n, y = xx;
while (1)
{
i++;
xx = (mul(xx, xx, n) + c) % n;
LL d = gcd(y - xx, n);
if (1 < d && d < n)
{ // 找到一个因数
return d;
}
if (y == xx)
{ // 出现循环，那么查找失败
return n;
}
if (i == k)
{ // 相当一个优化？
y = xx;
k <<= 1;
}
}
}
void find(LL n)
{ // 通过因数来找质因子
if (miller_rabin(n))
{
fac[cnt++] = n; // 记录质因子
return;
}
LL p = n;
while (p >= n)
p = pollard_rho(p, rand() % (n - 1) + 1); //如果转了一圈还是p那么继续
find(p);
find(n / p);
}
int main()
{
srand(251);
LL a, b;
cin>>a>>b;
if(a==1||b==1){
cout<<1;
return 0;
}
if (miller_rabin(a))
{
if (b % a == 0)
cout << 2;
else
cout << 1;
return 0;
}
if (miller_rabin(b))
{
if (a % b)
cout << 2;
else
cout << 1;
return 0;
}
cnt = 0;
find(a);
LL fa[1001];
memcpy(fa, fac, sizeof(fac));
sort(fa, fa + cnt);
int ss = cnt;
cnt = 0;
find(b);
sort(fac, fac + cnt);
int ans = 0;
for (int i = 0; i < ss; i++) {
if (i && fa[i] == fa[i - 1])continue;
for (int j = 0; j < cnt; j++) {
if (j && fac[j] == fac[j - 1])continue;
if (fac[j] == fa[i])ans++;
}
}
cout << ans+1;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef tuple<int,int,int> tii;
#define rep(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
int main(){
ll A,B; cin >> A >> B;
if(A<B) swap(A,B);
ll y = gcd(A,B);
ll yy = y;
ll x = 2;
ll ans = 1;
while(x*x<=y&&yy!=1){
if(yy%x==0){
ans++;
while(yy%x==0) yy /= x;
}
x++;
}
if(yy!=1) ans++;
cout << ans << endl;
} | 1 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define CLR(x) memset((x), false, sizeof(x))
const int MAXD = 12801;
const int MAXN = 81;
int A[2][MAXN][MAXN];
bool dp[MAXN][MAXN][MAXD];
int H, W;
int solve() {
CLR(dp);
dp[0][0][0] = true;
dp[0][1][0] = true;
dp[1][0][0] = true;
for (int i = 1; i <= H; ++i) {
for (int j = 1; j <= W; ++j) {
for (int k = 0; k < MAXD; ++k) {
int d = std::abs(A[0][i][j] - A[1][i][j]);
int nk1 = k + d;
if (nk1 < MAXD) {
dp[i][j][k] |= dp[i-1][j][nk1] | dp[i][j-1][nk1];
}
int nk2 = std::abs(k - d);
dp[i][j][k] |= dp[i-1][j][nk2] | dp[i][j-1][nk2];
}
}
}
for (int k = 0; k < MAXD; ++k) {
if (dp[H][W][k]) {
return k;
}
}
return -1;
}
int main() {
scanf(" %d%d", &H, &W);
for (int k = 0; k < 2; ++k) {
for (int i = 1; i <= H; ++i) {
for (int j = 1; j <= W; ++j) {
scanf("%d", &A[k][i][j]);
}
}
}
printf("%d\n", solve());
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int H, W;
cin >> H >> W;
vector<vector<int>> A(H, vector<int>(W)), B(H, vector<int>(W));
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
cin >> A.at(i).at(j);
}
}
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
cin >> B.at(i).at(j);
}
}
vector<vector<int>> d(H, vector<int>(W));
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
d.at(i).at(j) = abs(A.at(i).at(j) - B.at(i).at(j));
}
}
auto to_id = [&](int i, int j) {
return i * W + j;
};
vector<vector<bool>> dp(H * W, vector<bool>(80 * 160 + 1));
dp.at(to_id(0, 0)).at(d.at(0).at(0)) = true;
for (int i = 1; i < H; i++)
{
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(i - 1, 0)).at(k))
{
dp.at(to_id(i, 0)).at(abs(k + d.at(i).at(0))) = true;
dp.at(to_id(i, 0)).at(abs(k - d.at(i).at(0))) = true;
}
}
}
for (int j = 1; j < W; j++)
{
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(0, j - 1)).at(k))
{
dp.at(to_id(0, j)).at(abs(k + d.at(0).at(j))) = true;
dp.at(to_id(0, j)).at(abs(k - d.at(0).at(j))) = true;
}
}
}
for (int i = 1; i < H; i++)
{
for (int j = 1; j < W; j++)
{
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(i - 1, j)).at(k))
{
dp.at(to_id(i, j)).at(abs(k + d.at(i).at(j))) = true;
dp.at(to_id(i, j)).at(abs(k - d.at(i).at(j))) = true;
}
if (dp.at(to_id(i, j - 1)).at(k))
{
dp.at(to_id(i, j)).at(abs(k + d.at(i).at(j))) = true;
dp.at(to_id(i, j)).at(abs(k - d.at(i).at(j))) = true;
}
}
}
}
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(H - 1, W - 1)).at(k))
{
cout << k << endl;
break;
}
}
return 0;
}
| 1 |
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
#define V(a) a.begin(), a.end()
typedef set<int> s;
int main()
{
s a[2], C;
for (auto &i : a) {
int n, x;
cin >> n;
while (n--) {
cin >> x;
i.insert(x);
}
}
set_intersection(V(a[0]), V(a[1]), inserter(C, C.end()));
cout << C.size() << endl;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int *S = new int[n];
for (int i = 0; i < n; ++i) {
cin >> S[i];
}
int q;
cin >> q;
int *T = new int[q];
for (int i = 0; i < q; ++i) {
cin >> T[i];
}
int count = 0;
for (int i = 0; i < q; ++i) {
for (int j = 0; j < n; ++j) {
if (S[j] == T[i]) {
++count;
break;
}
}
}
cout << count << endl;
delete[] S;
delete[] T;
return 0;
} | 1 |
#include <iostream>
#include <cctype>
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
#include <complex>
#include <cstring>
#include <set>
using namespace std;
#define loop(i,a,b) for(int i=a; i<b; i++)
#define rep(i,a) loop(i,0,a)
int input[1111][3], res[1111];
int main(){
int a,b,c;
while(cin>>a>>b>>c && a){
int n; cin>>n;
rep(i,n){
rep(j,3)cin >> input[i][j];
cin>>res[i];
}
bool ok[1111]={}, bad[1111]={};
rep(k,2){
rep(i,n){
int a=0,b=0;
int x,y,z;
tie(x,y,z)=tie(input[i][0],input[i][1],input[i][2]);
for(int j : {x,y,z}){
if(ok[j])a++;
if(bad[j])b++;
}
if(res[i]){
if(a!=3){
ok[x]=ok[y]=ok[z]=true;
}
}else{
if(a==2 && b!=1){
for(int j : {x,y,z}){
if(!ok[j])bad[j]=true;
}
}
}
}
}
for(int i=1;i<=a+b+c;i++){
if(ok[i] && !bad[i])cout<<1;
else if(!ok[i] && bad[i])cout<<0;
else cout<<2;
cout<<endl;
}
}
} | #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
int a, b, c, n;
cin >> a >> b >> c >> n;
if(a == 0)
return 0;
vector<vector<int> > check(n, vector<int>(4));
for(int i=0; i<n; ++i){
for(int j=0; j<4; ++j)
cin >> check[i][j];
}
vector<int> quality(a+b+c+1, 2);
for(int i=0; i<n; ++i){
if(check[i][3] == 1){
quality[check[i][0]] = 1;
quality[check[i][1]] = 1;
quality[check[i][2]] = 1;
}
}
for(int i=0; i<n; ++i){
if(check[i][3] == 0){
if(quality[check[i][0]] == 1 && quality[check[i][1]] == 1)
quality[check[i][2]] = 0;
if(quality[check[i][1]] == 1 && quality[check[i][2]] == 1)
quality[check[i][0]] = 0;
if(quality[check[i][2]] == 1 && quality[check[i][0]] == 1)
quality[check[i][1]] = 0;
}
}
for(int i=1; i<=a+b+c; ++i)
cout << quality[i] << endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DD double
#define Pb push_back
#define Bp pop_back
#define Pf push_front
#define Fp pop_front
#define Ub upper_bound
#define Lb lower_bound
#define In insert
#define All(x) x.begin(), x.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define fast ios_base::sync_with_stdio(0);cin.tie(0)
#define X first
#define Y second
#define mx1 10
#define mx2 110
#define mx3 1010
#define mx4 10010
#define mx5 100010
#define mx6 1000010
typedef vector<LL> Vl;
typedef vector<DD> Vd;
typedef vector<bool> Vb;
typedef vector<Vl> VVl;
typedef pair<LL, LL> Pll;
typedef pair<DD, DD> Pdd;
typedef vector<Pll> Vpl;
typedef vector<Pdd> Vpd;
typedef queue<LL> Ql;
typedef stack<LL> Sl;
typedef deque<LL> Dl;
LL _set(LL N, LL pos) {return N = N | (1 << pos);}
LL _reset(LL N, LL pos) {return N = N & ~(1 << pos);}
bool _check(LL N, LL pos) {return (bool)(N & (1 << pos));}
bool _upper(char a) {return a >= 'A' && a <= 'Z';}
bool _lower(char a) {return a >= 'a' && a <= 'z';}
bool _digit(char a) {return a >= '0' && a <= '9';}
LL dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
LL dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
///**************************DONE****************************///
int dp[12][9 * mx6], g, d, p[12], c[12];
int stt(int id, int S)
{
if(id > d){
if(S < g)
return 1e7;
return 0;
}
if(dp[id][S] != -1)
return dp[id][S];
int ans = INT_MAX;
for(int i = 0; i < p[id]; i++){
ans = min(ans, i + stt(id + 1, S + i * id * 100));
}
ans = min(ans, p[id] + stt(id + 1, S + id * 100 * p[id] + c[id]));
return dp[id][S] = ans;
}
int main()
{
mem(dp, -1);
cin >> d >> g;
for(int i = 1; i <= d; i++)
cin >> p[i] >> c[i];
cout << stt(1, 0) << '\n';
return 0;
}
| #include <bits/stdc++.h>
int main(){
long long D, G;
std::cin >> D >> G;
G /= 100;
std::vector< int > P(D);
std::vector< int > C(D);
for(int i=0; i<D; i++){
std::cin >> P[i] >> C[i];
P[i];
C[i] /= 100;
}
std::vector< std::vector< int > > dp(D+1, std::vector< int >(G+1, 1e8));
dp[0][0] = 0;
for(int i=1; i<=D; i++){
std::vector< int > cur(G+1, 1e8);
cur[0] = 0;
for(int j=1; j<=G; j++){
if(i * P[i-1] + C[i-1] < j){
break;
}else if(i * P[i-1] < j){
cur[j] = P[i-1];
}else{
cur[j] = j / i + (j % i != 0);
}
}
int index_a1 = 1, index_a2 = 0, index_b1 = 0, index_b2 = 1;
dp[i][0] = 0;
while(index_a1 + index_a2 <= G){
int a = dp[i-1][index_a1] + cur[index_a2];
int b = dp[i-1][index_b1] + cur[index_b2];
if(a > b){
dp[i][index_a1 + index_a2] = b;
}else{
dp[i][index_a1 + index_a2] = a;
}
if(index_a1 == G || dp[i-1][index_a1+1] >= 1e8){
index_a2++;
}else{
index_a1++;
}
if(index_b2 == G || cur[index_b2+1] >= 1e8){
index_b1++;
}else{
index_b2++;
}
}
}
std::cout << dp[D][G] << std::endl;
return 0;
}
| 1 |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll ac(ll n, ll k) { ll a = 1; rep(i, 1, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
int main()
{
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(i, 0, n)cin >> v[i];
int score, M = 0;
rep(g, 0, min(n, k) + 1) {
rep(l, 0, g + 1) {
vector<int> s;
rep(i, 0, n) {
if (i < l || i >= n - g + l)s.push_back(v[i]);
}
sort(all(s));
int p = 0, m = min(k - g, (int)s.size());
for (; p < m; p++)if (s[p] > 0)break;
score = 0;
for (; p < s.size(); p++)score += s[p];
M = max(score, M);
s.erase(all(s));
}
}
printf("%d\n", M);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 50 + 5, mod = 1e9 + 7;
int n, k;
int a[N], dp[N][N][102];
int solve(int l, int r, int left)
{
if (l > r)
return 0;
if (dp[l][r][left] != -1)
return dp[l][r][left];
int ans = 0;
if (a[l] < 0)
{
if (left > 0)
ans = max(ans, solve(l + 1, r, left - 1) + a[l]);
if (left > 1)
ans = max(ans, solve(l + 1, r, left - 2));
}
if (a[l] >= 0 && left > 0)
ans = max(ans, solve(l + 1, r, left - 1) + a[l]);
if (a[r] < 0)
{
if (left > 0)
ans = max(ans, solve(l, r - 1, left - 1) + a[r]);
if (left > 1)
ans = max(ans, solve(l, r - 1, left - 2));
}
if (a[r] >= 0 && left > 0)
ans = max(ans, solve(l, r - 1, left - 1) + a[r]);
return dp[l][r][left] = ans;
}
int main()
{
//ios::sync_with_stdio(false);cin.tie(nullptr);ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
memset(dp, -1, sizeof dp);
cout << solve(0, n - 1, k);
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int gcd(int a,int b){return b%a ? gcd(b%a,a) : a;}
int main(){
int N;
cin>>N;
int a,b,c;
cin>>a>>b;
if(N==3) cin>>c;
int tmp=gcd(a,b);
if(N==3) tmp=gcd(tmp,c);
for(int i=1;i<=tmp;i++){
if(tmp%i==0) cout<<i<<endl;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define rg register
#define rep(i,a,b) for (rg int i=a;i<=b;i++)
#define per(i,a,b) for (rg int i=b;i>=a;i--)
#define pb push_back
#define lowbit(x) (x&(-x))
#define mk make_pair
#define VI vector<int>
#define pii pair<int,int>
#define pLL pair<long long,long long>
#define fi first
#define se second
#define il inline
#define ll long long
#define db double
#define ld long double
#define inf 0x3f3f3f3f
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<15,stdin),p1==p2)?EOF:*p1++)
char buf[1<<15],*p1 = buf,*p2 = buf;
inline ll read(){
#define num ch-'0'
char ch;bool flag=0;ll res;
while(!isdigit(ch=getc()))
(ch=='-')&&(flag=true);
for(res=num;isdigit(ch=getc());res=res*10ll+num);
(flag)&&(res=-res);
#undef num
return res;
}
inline void write(ll x){
if (x < 0) x = ~x + 1ll, putchar('-');
if (x > 9) write(x / 10ll);
putchar(x % 10ll + '0');
}
#define mid ((l + r)>>1)
#define ls (x<<1)
#define rs ((x<<1)|1)
#undef mid
#undef ls
#undef rs
ll gcd(ll a,ll b) {return b == 0?a:gcd(b,a%b);}
void solve()
{
ll a = read(),b = read();
ll c = gcd(a,b);
int tot = 1;
for(ll i =2 ;i*i<=c;i++)
{
if(c%i==0)
{
while(c%i==0) c/=i;
tot++;
}
}
if(c>1) tot++;
cout<<tot<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("data.txt","r",stdin);
#endif
// int T = read();
// while(T--)
solve();
} | 0 |
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
class Dice{
private:
public:
int num[6];
void roll(char c){
int b;
if(c == 'S'){
b = num[0];
num[0] = num[4];
num[4] = num[5];
num[5] = num[1];
num[1] = b;
}
if(c == 'W'){
b = num[0];
num[0] = num[2];
num[2] = num[5];
num[5] = num[3];
num[3] = b;
}
if(c == 'N'){
b = num[0];
num[0] = num[1];
num[1] = num[5];
num[5] = num[4];
num[4] = b;
}
if(c == 'E'){
b = num[0];
num[0] = num[3];
num[3] = num[5];
num[5] = num[2];
num[2] = b;
}
}
};
bool isSame(Dice d1, Dice d2){
int top = d1.num[0], front = d1.num[1];
if(d2.num[2] == front || d2.num[3] == front) d2.roll('W');
int cnt = 0;
while(d2.num[1] != front){
d2.roll('S');
if(++cnt == 4) return false;
}
cnt = 0;
while(d2.num[0] != top){
d2.roll('W');
if(++cnt == 4) return false;
}
for(int i=2;i<6;i++){
if(d1.num[i] != d2.num[i]){
return false;
}
}
return true;
}
bool isAllDiff(vector <Dice> d, int n){
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
if(isSame(d[i], d[j])){
return false;
}
}
}
return true;
}
int main(){
vector <Dice> vec;
Dice d;
int n;
cin >> n;
for(int i=0;i<n;i++){
for(int j=0;j<6;j++){
cin >> d.num[j];
}
vec.push_back(d);
}
if(isAllDiff(vec, n)) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| #include<iostream>
#include<string>
#include<stdio.h>
using namespace std;
void dice1();
void dice2();
void dice3();
void dice4();
class DICE{
int face[6],a;
public:
bool operator==(const DICE&di)const{
int cont=0;
for(int i=0;i<6;++i){
if(face[i]==di.face[i]){
cont++;
}
}
if(cont==6){
return true;
}
else{
return false;
}
}
bool operator!=(const DICE&di)const{
return !(*this==di);
}
void set(int&f,int&f1,int&f2,int&f3,int&f4,int&f5){
face[0]=f;face[1]=f1;face[2]=f2;face[3]=f3;face[4]=f4;face[5]=f5;
}
void N(){
a=face[0];
face[0]=face[1];
face[1]=face[5];
face[5]=face[4];
face[4]=a;
}
void E(){
a=face[0];
face[0]=face[3];
face[3]=face[5];
face[5]=face[2];
face[2]=a;
}
void S(){
a=face[0];
face[0]=face[4];
face[4]=face[5];
face[5]=face[1];
face[1]=a;
}
void W(){
a=face[0];
face[0]=face[2];
face[2]=face[5];
face[5]=face[3];
face[3]=a;
}
void output(){
cout<<face[0]<<endl;
}
int up(){
return face[0];
}
void turn(){
a=face[1];
face[1]=face[3];
face[3]=face[4];
face[4]=face[2];
face[2]=a;
}
int front(){
return face[1];
}
int right(){
return face[2];
}
void allout(){
for(int i=0;i<6;++i){
cout<<face[i]<<" ";
}
cout<<endl;
}
void toupper(int n){
if(n<=3){
a=face[0];
face[0]=face[1];
face[1]=face[5];
face[5]=face[4];
face[4]=a;
}
else if(n==4){
a=face[0];
face[0]=face[3];
face[3]=face[5];
face[5]=face[2];
face[2]=a;
}
else if(n==5){
a=face[0];
face[0]=face[3];
face[3]=face[5];
face[5]=face[2];
face[2]=a;
a=face[0];
face[0]=face[3];
face[3]=face[5];
face[5]=face[2];
face[2]=a;
}
}
};
bool judge(DICE,DICE);
int main(){
dice4();
return 0;
}
void dice1(){
DICE a;
int d[6];string str;
for(int i=0;i<6;++i){
cin>>d[i];
}
a.set(d[0],d[1],d[2],d[3],d[4],d[5]);
getline(cin,str);
getline(cin,str);
for(int i=0;i<str.size();++i){
if(str[i]=='E'){
a.E();
}
else if(str[i]=='S'){
a.S();
}
else if(str[i]=='W'){
a.W();
}
else if(str[i]=='N'){
a.N();
}
}
a.output();
return;
}
void dice2(){
DICE a;
int d[6],p,u;
for(int i=0;i<6;++i){
cin>>d[i];
}a.set(d[0],d[1],d[2],d[3],d[4],d[5]);
int n;
cin>>n;
for(int i=0;i<n;++i){
cin>>p>>u;
int k=0;
while(1){
k++;
if(k<=5){
a.E();
}
else{
a.N();
}
if(p==a.up()){
break;
}
}
k=0;
while(1){
k++;
a.turn();
if(u==a.front()){
break;
}
}
cout<<a.right()<<endl;
}
return;
}
void dice3(){
DICE a,b;
int d[6][2];
for(int i=0;i<2;++i){
for(int j=0;j<6;++j){
cin>>d[j][i];
}
}
a.set(d[0][0],d[1][0],d[2][0],d[3][0],d[4][0],d[5][0]);
b.set(d[0][1],d[1][1],d[2][1],d[3][1],d[4][1],d[5][1]);
if(judge(a,b)){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
}
bool judge(DICE a,DICE b){
bool bo1=false,bo2=false;
for(int i=0;i<6;++i){
b.toupper(i);
for(int j=0;j<4;++j){
if(a==b){
return true;
}
b.turn();
}
}
return false;
}
void dice4(){
int n,d[6][101];
DICE a[101];
cin>>n;
for(int i=0;i<n;++i){
for(int j=0;j<6;++j){
cin>>d[j][i];
}
}
for(int i=0;i<n;++i){
a[i].set(d[0][i],d[1][i],d[2][i],d[3][i],d[4][i],d[5][i]);
}
for(int i=0;i<n-1;++i){
for(int j=i+1;j<n;++j){
if(judge(a[i],a[j])){
cout<<"No"<<endl;
return ;
}
else {
}
}
}
cout<<"Yes"<<endl;
return ;
} | 1 |
#include<iostream>
#include<cmath>
#include<stdio.h>
#include<string.h>
using namespace std;
struct node
{
double x,y;
};
double PI=acos(-1.0);
int n;
node p[111];
double ans[111];
void merge(double &from,double &to,double ff,double tt)
{
if(from>ff)
{
swap(from,ff);
swap(to,tt);
}
if(to==-2.0*PI)
{
from=ff;to=tt;
return ;
}
double f0,t0;
f0=max(from,ff);
t0=min(to,tt);
if(f0<=t0)
{
from=f0;to=t0;
return ;
}
if(tt>PI)
{
ff-=2.0*PI;
tt-=2.0*PI;
f0=max(from,ff);
t0=min(to,tt);
}
from=f0;to=t0;
return ;
}
int main()
{
int i,j,k;
double from,to;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>p[i].x>>p[i].y;
}
for(i=1;i<=n;i++)
{
from=-PI*4.0;
to=-PI*2.0;
for(j=1;j<=n;j++)
{
if(i==j)continue;
node l;
l.x=p[j].x-p[i].x;
l.y=p[j].y-p[i].y;
double e=atan2(l.x,l.y);
//cout<<atan2(0,-1)<<endl;
e+=PI/2.0;
if(e>PI)e-=2.0*PI;
double ff,tt;
ff=e;tt=e+PI;
//cout<<ff<<' '<<tt<<" %%%"<<endl;
merge(from,to,ff,tt);
//cout<<from<<' '<<to<<endl;
}
cout.precision(7);
cout.setf(ios::fixed);
cout<<max((to-from)/(PI*2.0),0.0)<<endl;
}
return 0;
}
| #include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define LL long long
#define double long double
using namespace std;
const double pi=acos(-1);
struct poLL {LL x,y,num;}p[110],a[110];
double ans[110];
LL multi(poLL p1,poLL p2,poLL p0)
{
LL x1=p1.x-p0.x,y1=p1.y-p0.y;
LL x2=p2.x-p0.x,y2=p2.y-p0.y;
return x1*y2-x2*y1;
}
LL n,top=0,sta[110];
LL dis(poLL a,poLL b) {return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);}
bool cmp(poLL a,poLL b)
{
LL t1=multi(b,a,p[1]);
return t1==0?dis(p[1],a)<dis(p[1],b):t1>0;
}
void solve()
{
for(LL i=2;i<=n;i++)
if((p[1].x==p[i].x)?(p[i].y<p[1].y):(p[i].x<p[1].x)) swap(p[1],p[i]);
sort(p+2,p+n+1,cmp);
sta[++top]=1;
for(LL i=2;i<=n;i++)
{
while(top>1&&multi(p[sta[top]],p[sta[top-1]],p[i])<0) top--;
sta[++top]=i;
}
}
double get(poLL p1,poLL p2,poLL p0)
{
LL x1=p1.x-p0.x,y1=p1.y-p0.y;
LL x2=p2.x-p0.x,y2=p2.y-p0.y;
return (double)(x1*x2+y1*y2)/(sqrt(x1*x1+y1*y1)*sqrt(x2*x2+y2*y2));
}
void calc()
{
if(top==0) for(LL i=1;i<=top;i++) ans[p[sta[i]].num]=0.5;
else
{
sta[0]=sta[top];sta[top+1]=sta[1];
for(LL i=1;i<=top;i++)
{
double tmp=get(p[sta[i-1]],p[sta[i+1]],p[sta[i]]);
double s=pi-acos(tmp);
ans[p[sta[i]].num]=s/(pi*2);
}
}
}
int main()
{
scanf("%lld",&n);
for(LL i=1;i<=n;i++) scanf("%lld %lld",&p[i].x,&p[i].y),p[i].num=i;
if(n==1) return puts("1.000000000000"),0;
solve();calc();
for(LL i=1;i<=n;i++) printf("%.9Lf\n",ans[i]);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll l,r,ans=2e9;
cin >> l >> r;
if (r-l+1 <= 2019) {
for (ll i=l; i<r; i++) {
for (ll j=i+1; j<=r; j++) {
ans = min(ans, ((i%2019)*(j%2019))%2019);
}
}
cout << ans << '\n';
} else {
cout << 0 << '\n';
}
return 0;
}
| #include<bits/stdc++.h>
#include<cctype>
using namespace std;
#define rep(i,n) for (int i=0;i<(n);i++)
#define all(v) (v).begin(),(v).end()
typedef long long int ll;
#define pi 3.1415926535897932384
#define E9 1000000000
#define eps 1e-4
#define pii pair<int,int>
int main(){
int N, K; cin >> N >> K;
int x[N]; rep(i,N) cin >> x[i];
int ans = 1000000000;
rep(i,N-K+1){
int MAX = x[i+K-1], MIN = x[i];
int tmp;
if (MIN > 0 || MAX<0 ){
tmp = max(abs(MIN), abs(MAX));
}
else {
tmp = MAX - MIN + min(MAX, abs(MIN));
}
ans = min(ans, tmp);
}
cout << ans << endl;
// cout << fixed << setprecision(10);
return 0;
}
| 0 |
/*
* d.cc:
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_N = 1000000;
const int MAX_M = 20;
/* typedef */
typedef vector<int> vi;
typedef queue<int> qi;
typedef pair<int,int> pii;
/* global variables */
int as[MAX_N], gs[MAX_M];
/* subroutines */
int insertion_sort(int as[], int n, int g) {
int cnt = 0;
for (int i = g; i < n; i++) {
int v = as[i];
int j = i - g;
while (j >= 0 && as[j] > v) {
as[j + g] = as[j];
j = j - g;
cnt++;
}
as[j + g] = v;
}
return cnt;
}
int shell_sort(int as[], int n, int gs[], int m) {
int cnt = 0;
for (int i = 0; i < m; i++)
cnt += insertion_sort(as, n, gs[i]);
return cnt;
}
/* main */
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> as[i];
int g;
for (g = 1; g <= n; g <<= 1);
int m = 0;
for (g >>= 1; g > 0; g >>= 1, m++) gs[m] = g;
int cnt = shell_sort(as, n, gs, m);
printf("%d\n", m);
for (int i = 0; i < m; i++) {
if (i) putchar(' ');
printf("%d", gs[i]);
}
putchar('\n');
printf("%d\n", cnt);
for (int i = 0; i < n; i++) printf("%d\n", as[i]);
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pii;
inline int rd(int f = 1, int x = 0, char ch = ' ')
{
while(!isdigit(ch = getchar())) if(ch == '-') f = -1;
while(isdigit(ch)) x = x*10+ch-'0', ch = getchar();
return f*x;
}
const int N = 5e5+5, oo = 0x3f3f3f3f;
int n, p, q, l[N], r[N], ans; pii v[N];
int main()
{
n = rd(), p = oo; for(int i = 1; i <= n; ++i) l[i] = rd(), r[i] = rd(), p = min(p, r[i]), q = max(q, l[i]);
for(int i = 1; i <= n; ++i) v[i].fi = p-l[i]+1, v[i].se = r[i]-q+1, ans = max(ans, r[i]-l[i]+1+max(p-q+1, 0));
sort(v+1, v+n+1); for(int i = 1, w = oo; i < n; ++i) w = min(w, v[i].se), ans = max(ans, w+v[i+1].fi);
printf("%d\n", ans);
return 0;
} | 0 |
// lcmとか__builtin_popcountとかはg++ -std=c++17 default.cppみたいなかんじで
#include <bits/stdc++.h>
#define mod 1000000007
#define INF LLONG_MAX
#define ll long long
#define ln cout<<endl
#define Yes cout<<"Yes"<<endl
#define NO cout<<"NO"<<endl
#define YES cout<<"YES"<<endl
#define No cout<<"No"<<endl
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
using namespace std;
ll dx[4]={1,0,-1,0};
ll dy[4]={0,1,0,-1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b,c,d,e,n,k,maxi=0,f=0,mini=INF,sum=0,q;
string str,stra,ko;
ll x,y,w,z;
char hoge,fuga;
cin>>n;
b=n;
while(b>0){
sum+=b%10;
b/=10;
}
if(n%sum) No;
else Yes;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N=0, a=0, b=0, c=10;
cin >> N;
a = N % c;
for(int i=0; i<8; i++){
if(c > N){
break;
}
b = N / c;
a += b % 10 ;
c = c * 10;
}
if(N % a == 0){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
} | 1 |
#include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repr(i, n) for (ll i = n - 1; i >= 0; --i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
using namespace std;
void solve(void)
{
string s;
cin >> s;
if (s.length() == 2)
{
cout << s << endl;
return;
}
reverse(all(s));
cout << s << endl;
}
int main(void)
{
solve();
} | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <string>
#include <numeric>
#include <math.h>
using namespace std;
double condition = 0.0;
void func()
{
int X;
cin >> X;
int Y, Z;
Y = X / 500;
Z = (X % 500) / 5;
cout << 1000 * Y + Z * 5 << endl;
}
int main() {
// while(1)
func();
return 0;
}
| 0 |
#pragma GCC optimize("Ofast")
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define all(a) (a).begin(), (a).end()
int main() {
int R;
cin >> R;
string s;
if(R < 1200) s = "ABC";
else if(R < 2800) s = "ARC";
else s = "AGC";
cout << s << endl;
}
| #include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define LCM(a, b) (a) / __gcd((a), (b)) * (b)
#define CEIL(a, b) (a)/(b)+(((a)%(b))?1:0)
#define log_2(a) (log((a)) / log(2))
#define ln '\n'
using namespace std;
using LL = long long;
using ldouble = long double;
using P = pair<int, int>;
using LP = pair<LL, LL>;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1e9 + 7;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<LL> Div(LL n) {
vector<LL> ret;
for(LL i = 1; i * i <= n; ++i) {
if(n % i == 0) {
ret.pb(i);
if(i * i != n) ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
cout << (N - 2) * 180 << endl;
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <cctype>
#include <algorithm>
using namespace std;
typedef long long lint;
#define cout cerr
#define ni (next_num<int>())
template<class T>inline T next_num(){
T i=0;char c;
while(!isdigit(c=getchar())&&c!='-');
bool flag=c=='-';
flag?(c=getchar()):0;
while(i=i*10-'0'+c,isdigit(c=getchar()));
return flag?-i:i;
}
template<class T1,class T2>inline void apmax(T1 &a,const T2 &b){if(a<b)a=b;}
const int N=101;
char mat[N][N];
short f[N][N][N][N],sum[N][N];
inline int asksum(int x1,int x2,int y1,int y2){
return x1<=x2&&y1<=y2?sum[x2][y2]-sum[x1-1][y2]-sum[x2][y1-1]+sum[x1-1][y1-1]:0;
}
int main(){
int n=ni,m=ni,ex,ey;
memset(sum,0,sizeof(sum));
for(int i=1;i<=n;i++){
scanf("%s",mat[i]+1);
for(int j=1;j<=m;j++){
sum[i][j]=(mat[i][j]=='o')+sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1];
if(mat[i][j]=='E'){
ex=i,ey=j;
}
}
}
for(int i=ex;i>=1;i--){
for(int j=ex;j<=n;j++){
for(int k=ey;k>=1;k--){
for(int l=ey;l<=m;l++){
short &F=f[i][j][k][l]=0;
int xs=max(1+(j-ex),i),xt=min(n-(ex-i),j);
int ys=max(1+(l-ey),k),yt=min(m-(ey-k),l);
if(i<ex)apmax(F,f[i+1][j][k][l]+asksum(xs,i,ys,yt));
if(j>ex)apmax(F,f[i][j-1][k][l]+asksum(j,xt,ys,yt));
if(k<ey)apmax(F,f[i][j][k+1][l]+asksum(xs,xt,ys,k));
if(l>ey)apmax(F,f[i][j][k][l-1]+asksum(xs,xt,l,yt));
}
}
}
}
printf("%d\n",(int)f[1][n][1][m]);
return 0;
} | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template<typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v) out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 1000010
int dp[SIZE][2];
int main() {
char S[SIZE];
scanf("%s", S);
int N = strlen(S);
for (int i = 0; i <= N; i++)
dp[i][0] = dp[i][1] = INF;
dp[0][0] = 0;
dp[0][1] = 1;
for (int i = 0; i < N; i++) {
int p = S[i] - '0';
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + p);
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1] + 10 - p);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + p + 1);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + 10 - p - 1);
}
cout << dp[N][0] << endl;
return 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;
struct UnionFind
{
void init(int n)
{
mN = n;
mNodeTbl.resize(mN);
REP(i, mN)
{
mNodeTbl[i] = i;
}
}
int find(int x)
{
if (x == mNodeTbl[x])
return x;
return mNodeTbl[x] = find(mNodeTbl[x]);
}
bool same(int x, int y)
{
return find(x) == find(y);
}
void unit(int x, int y)
{
x = find(x);
y = find(y);
mNodeTbl[x] = y;
}
int mN;
vector<int> mNodeTbl;
};
struct Edge
{
int a;
int b;
ll w;
};
Edge e[100005];
int main()
{
int V, E;
cin >> V >> E;
REP(i, E)
{
cin >> e[i].a >> e[i].b >> e[i].w;
}
sort(e, e + E, [](Edge a, Edge b) { return a.w < b.w; });
UnionFind uf;
uf.init(V);
ll cost = 0;
REP(i, E)
{
Edge t = e[i];
if (uf.same(t.a, t.b))
continue;
cost += t.w;
uf.unit(t.a, t.b);
}
cout << cost << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
typedef pair<int,int> ii;
typedef pair<int,ii> iii;
class UnionFindDS{
private:
vector<int> p, h, sz; // parent, height (rank), size
int num;
public:
UnionFindDS(int N){
p.assign(N,0); for (int i=0; i<N; i++) p[i] = i;
h.assign(N,0); sz.assign(N,1);
num = N;
}
int numSets(){ return num; }
int findSet(int i){ return p[i] == i ? i : p[i] = findSet(p[i]); }
int sizeSet(int i){ return sz[findSet(i)]; }
bool isSameSet(int i, int j){ return findSet(i) == findSet(j); }
void unionSet(int i, int j){
int x = findSet(i), y = findSet(j);
if (x == y) return;
num--;
if (h[x] > h[y]){ p[y] = x; sz[x] += sz[y]; }
else { p[x] = y; sz[y] += sz[x]; h[y] += (h[y] == h[x]); }
}
};
priority_queue< iii,vector<iii>,greater<iii> > pq;
int main(){
ios_base::sync_with_stdio(0);
int V, E;
cin >> V >> E;
int u, v, w;
for (int i=0; i<E; i++){
cin >> u >> v >> w;
pq.push(iii(w,ii(u,v)));
}
UnionFindDS uf(V);
int sum = 0;
while (uf.numSets() > 1 && !pq.empty()){
iii front = pq.top(); pq.pop();
u = front.se.fi; v = front.se.se; w = front.fi;
if (uf.isSameSet(u,v)) continue;
uf.unionSet(u,v); sum += w;
}
if (uf.numSets() > 1) cout << -1 << endl; // impossible to form spanning tree
else cout << sum << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define loop(i, n) for(int i = 0;i < int(n);i++)
#define rloop(i, n) for(int i = int(n);i >= 0;i--)
#define range(i, a, b) for(int i = int(a);i <= int(b);i++)
#define SZ(c) int(c.size())
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define PI acos(-1)
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define sfi1(v) scanf("%d",&v)
#define sfi2(v1, v2) scanf("%d %d",&v1,&v2)
#define sfi3(v1, v2, v3) scanf("%d %d %d",&v1,&v2,&v3)
#define sfll1(v) scanf("%I64d",&v);
#define sfll2(v1, v2) scanf("%I64d %I64d",&v1,&v2)
#define sfll3(v1, v2, v3) scanf("%I64d %I64d %I64d",&v1,&v2,&v3)
#define endl '\n'
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e5 + 5;
const int LG = 18;
int up[N][LG];
int arr[N];
int n, l, q;
void run_case() {
cin >> n;
loop(i, n)cin >> arr[i];
cin >> l >> q;
rloop(i, n - 1) {
int par = i == n - 1 ? n - 1 : (upper_bound(arr + i, arr + n, arr[i] + l) - arr - 1);
up[i][0] = par;
for (int k = 1; k < LG; ++k)
up[i][k] = up[up[i][k - 1]][k - 1];
}
while (q--) {
int a, b;
cin >> a >> b;
a--, b--;
if (a > b)swap(a, b);
int ans = 1;
for (int i = LG - 1; i >= 0; i--) {
if (up[a][i] < b) {
a = up[a][i];
ans += 1 << i;
}
}
cout << ans << endl;
}
}
int main() {
#ifndef ONLINE_JUDGE
// freopen("in.in", "r", stdin);
// freopen("out.in", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
// cin >> T;
while (T--)run_case();
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
int x[MAXN], st[MAXN][18];
int main()
{
int n; scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
int L, Q; scanf("%d%d", &L, &Q);
// memset(st, 0x3f3f3f3f, sizeof(st));
for (int i = 1; i <= n; i++)
st[i][0] = min(n, (int)(upper_bound(x + 1, x + 1 + n, x[i] + L) - x - 1));
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++)
st[i][j] = st[st[i][j - 1]][j - 1];
while (Q--)
{
int l, r; scanf("%d%d", &l, &r);
if (l > r) swap(l, r);
int res = 0;
for (int j = 17; j >= 0; j--)
if (st[l][j] < r) res += (1 << j), l = st[l][j];
printf("%d\n", res + 1);
}
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(){
while(1){
int a, b, c, n, list[1001][4], parts[301], judge, defect;
cin >> a >> b >> c >> n;
if(a == 0 && b == 0 && c == 0){
break;
}
for(int i = 1; i <= a + b + c; i++){
parts[i] = 2;
}
for(int i = 0; i < n; i++){
for(int j = 0; j < 4; j++){
cin >> list[i][j];
}
if(list[i][3] == 1){
for(int k = 0; k < 3; k++){
parts[list[i][k]] = 1;
}
}
}
for(int i = 0; i < n; i++){
if(!list[i][3]){
judge = 0;
for(int j = 0; j < 3; j++){
if(parts[list[i][j]] == 1){
judge++;
} else{
defect = j;
}
}
if(judge == 2){
parts[list[i][defect]] = 0;
}
}
}
for(int i = 1; i <= a + b + c; i++){
cout << parts[i] << endl;
}
}
return 0;
} | #include <stdio.h>
int main(){
int i,n,pm,pj,pe;
double avg,emav;
char type;
scanf("%d",&n);
while(n!=0){
for(i=0;i<n;i++){
scanf("%d%d%d",&pm,&pe,&pj);
avg = (pm+pe+pj) / 3.0;
emav = (pm+pe) / 2.0;
if(pm==100.0||pe==100.0||pj==100.0||emav>=90.0||avg>=80.0) type = 'A';
else if(avg>=70.0) type = 'B';
else if(avg>=50.0&&(pe>=80.0||pm>=80.0)) type = 'B';
else type = 'C';
printf("%c\n",type);
}
scanf("%d",&n);
}
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <functional>
#define fs first
#define se second
using namespace std;
typedef long long llong;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<llong, llong> pll;
typedef pair<ld, ld> pdd;
int n, q;
struct segtree {
static const llong inf = 1e18;
llong offset, seg[1 << 19];
segtree() : offset(0) {
for (int i = 1 << 19; i--; ) seg[i] = inf;
}
void update(int i, int s, int e, int x, llong v) {
if (s == e) {
seg[i] = min(seg[i], v);
return;
}
int m = (s + e) / 2;
if (x <= m) update(i << 1, s, m, x, v);
else update(i << 1 | 1, m + 1, e, x, v);
seg[i] = min(seg[i << 1], seg[i << 1 | 1]);
}
void update(int x, llong v) {
update(1, 1, n, x, v - offset);
}
llong query(int i, int s, int e, int x, int y) const {
if (e < x || y < s) return inf;
if (x <= s && e <= y) return seg[i];
int m = (s + e) / 2;
return min(query(i << 1, s, m, x, y), query(i << 1 | 1, m + 1, e, x, y));
}
llong query(int x, int y) const {
return offset + query(1, 1, n, x, y);
}
llong getans(int i, int s, int e) const {
if (s == e) return seg[i] + s;
int m = (s + e) / 2;
return min(getans(i << 1, s, m), getans(i << 1 | 1, m + 1, e));
}
llong getans() const {
return getans(1, 1, n) + offset;
}
} AP, AN, BP, BN;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int A, B, x, p;
cin >> n >> q >> A >> B >> x;
AP.update(B, abs(A - x) + B);
AN.update(B, abs(A - x) - B);
BP.update(A, abs(B - x) + A);
BN.update(A, abs(B - x) - A);
while (--q) {
p = x;
cin >> x;
llong AxBp = min({ BP.query(x, n) - x, BN.query(1, x) + x });
llong ApBx = min({ AP.query(x, n) - x, AN.query(1, x) + x });
llong d = abs(x - p);
AP.offset += d; AN.offset += d; BP.offset += d; BN.offset += d;
AP.update(p, AxBp + p);
AN.update(p, AxBp - p);
BP.update(p, ApBx + p);
BN.update(p, ApBx - p);
}
printf("%lld\n", min(AN.getans(), BN.getans()));
} | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<string>
#include<sstream>
#include<iomanip>
#include<utility>
#include<cmath>
#include<set>
#include<list>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long int ll;
const int MAX=100000;
const int INFTY=1<<30;
int n,col[MAX],d[MAX];
vector<pair<int,int>> Q[MAX];//target,weight
void dijkstra(int s)
{
priority_queue<pair<int,int>> PQ;//weight,id
for(int i=0;i<n;i++)
{
d[i]=INFTY;
col[i]=0;
}
d[s]=0;
PQ.push(make_pair(0,s));
col[s]=1;
while(!PQ.empty())
{
pair<int,int> f=PQ.top();PQ.pop();
int u=f.second;
col[u]=2;
if(d[u]<f.first*(-1))continue;
for(int j=0;j<Q[u].size();j++)
{
int v=Q[u][j].first;
if(col[v]==2)continue;
if(d[u]+Q[u][j].second<d[v])
{
d[v]=d[u]+Q[u][j].second;
PQ.push(make_pair(d[v]*(-1),v));
col[v]=1;
}
}
}
for(int i=0;i<n;i++)
{
if(d[i]==INFTY)cout<<"INF"<<endl;
else cout<<d[i]<<endl;
}
return;
}
int main()
{
cin>>n;
int u;int m;cin>>m>>u;
int s,t,w;
for(int i=0;i<m;i++)
{
cin>>s>>t>>w;
Q[s].push_back(make_pair(t,w));
}
dijkstra(u);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i,s,e) for(int (i) = (s);(i) <= (e);(i)++)
#define all(x) x.begin(),x.end()
i64 MOD = 998244353;
long long inv_mod(long long a, long long m = MOD) {
long long b, x, u, q, abs_m, tmp;
abs_m = (m < 0) ? -m : m;
b = m;
x = 1;
u = 0;
while (b > 0) {
q = a / b;
tmp = u;
u = x - q * u;
x = tmp;
tmp = b;
b = a - q * b;
a = tmp;
}
return (x < 0) ? abs_m + x : x;
}
i64 fact[101010];
i64 inv[101010];
void init() {
fact[0] = 1;
for(int i = 1;i < 101010;i++) {
fact[i] = fact[i - 1] * i % MOD;
}
inv[101010 - 1] = inv_mod(fact[101010 - 1]) % MOD;
for(int i = 101010 - 1;i >= 1;i--) {
inv[i - 1] = inv[i] * i % MOD;
}
}
i64 comp(i64 n, i64 k) {
if(n < k) return 0;
if (n < 0 || k < 0) return 0;
return fact[n] * inv[k] % MOD * inv[n - k] % MOD;
}
int main() {
init();
i64 K, N;
cin >> K >> N;
for(int i = 2; i <= 2 * K;i++) {
i64 p = i;
if(i > K + 1) p = (K + 1) * 2 - p;
p /= 2;
i64 ans = 0;
for(int j = 0;j <= p;j++) {
auto res = comp(p, j) * comp(K + N - 2 * j - 1, N - 2 * j) % MOD;
if(j & 1) ans = (ans - res % MOD + MOD) % MOD;
else ans = (ans + res) % MOD;
}
cout << ans << endl;
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
map<ll, ll> prime_factor(ll n) {
map< ll, ll > ret;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
const int 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(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;
}
int main(){
ll n, m;
cin >> n >> m;
map<ll,ll> mp = prime_factor(m);
COMinit();
ll ans = 1;
for(auto v : mp){
ll p = v.second;
ans *= COM(n+p-1, p);
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;
int gcd(int a, int b){
while(b){
int r = a % b;
a = b;
b = r;
}
return a;
}
int main(){
list<int> ls;
list<int>::iterator it = ls.begin();
int n, a, b, c;
cin >> n >> a >> b >> c;
a = gcd(a, b);
if(n == 3) a = gcd(a, c);
for(int i = 1; i * i <= a; ++i){
if(a % i == 0){
ls.insert(it, i);
if(i * i < a) it = ls.insert(it, a / i);
}
}
copy(ls.begin(), ls.end(), ostream_iterator<int>(cout, "\n"));
} | #include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <math.h>
//#define PI 3.141592653589
using namespace std;
int main()
{
int n;
long seisuu[3];
cin >> n;
for (int i=0; i<n; i++) cin >> seisuu[i];
sort(seisuu, seisuu+n);
for (int i=1; i<=seisuu[0]; i++)
{
if (n == 2)
{
if (seisuu[0]%i==0 && seisuu[1]%i==0)
{
cout << i << endl;
}
} else {
if (seisuu[0]%i==0 && seisuu[1]%i==0 && seisuu[2]%i==0)
{
cout << i << endl;
}
}
}
//for (int i=0; i<n; i++) cout << seisuu[i] << endl;
return 0;
} | 1 |
#include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
using namespace std;
#define N 1010
int MOD = 1000000007;
int fac[N+1];
int inv[N+1];
ll bitpow(ll x,ll n){
ll ans = 1;
while(n > 0){
if(n%2 == 1) ans = ans * x % MOD;
x = x * x %MOD;
n = n >> 1;
}
return ans;
}
ll COM(ll n,ll k){
return fac[n]*inv[k]%MOD*inv[n-k]%MOD;
}
int dp[1010][1010] = {0};
signed main(){
int n,a,b,c,d;
cin >> n >> a >> b >> c >> d;
fac[0] = 1;
inv[0] = 1;
for(int i = 1;i <= N;i++){
fac[i] = fac[i-1]*i%MOD;
inv[i] = bitpow(fac[i],MOD-2)%MOD;
}
dp[a-1][0] = 1;
for(int i = a;i <= b;i++){
for(int j = 0;j <= n;j++){
dp[i][j] = dp[i-1][j];
for(int k = c;k <= d;k++){
if(j-i*k < 0 || i*k > n)break;
dp[i][j] += dp[i-1][j-i*k] * fac[n-(j-i*k)] %MOD * inv[n-(j-i*k) - i*k] %MOD * inv[k]%MOD * bitpow(inv[i],k)%MOD;
dp[i][j] %= MOD;
// if(i == 3){
// //cerr << "j : dp[i-1][j-i*k] : fac[n-(j-i*k)] : inv[n-i*k] : inv[k] : bitpow(inv[i],k)" << endl;
// //cerr << j << " " << dp[i-1][j-i*k] << " : " << fac[n-(j-i*k)]<< " : "<< inv[n-i*k] << " : "<< inv[k] << " : "<< bitpow(inv[i],k);
// //cerr << endl;
// }
}
}
}
cout << dp[b][n] << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl https://yahoo-procon2019-qual.contest.atcoder.jp/tasks/yahoo_procon2019_qual_d
// rm -r -f test;oj dl http://arc067.contest.atcoder.jp/tasks/arc067_c | #include<bits/stdc++.h>
#define ll long long
using namespace std;
const int mod = 1e9+7;
int f[301000][3][3],n;
char s[301000];
void upd(int&a,int b){a+=b;if(a>=mod) a-=mod;}
int main(){
ios::sync_with_stdio(0);
cin>>s+1;
int n=strlen(s+1);
f[1][0][0]=1;
for(int i=1;i<=n;i++)
for(int j=0;j<=2;j++)
for(int k=0;k<=2;k++){
if(s[i]!='0') upd(f[i+1][k?j:min(2,j+1)][max(0,k-1)],f[i][j][k]);
if(s[i]!='1') upd(f[i+1][j][k+1>2?1:k+1],f[i][j][k]);
}
cout<<(0ll+f[n+1][1][0]+f[n+1][2][1]+f[n+1][2][2]+f[n+1][2][0])%mod<<'\n';
return 0;
}
| 0 |
#pragma target("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef unordered_map<ll, ll> U_MAP;
typedef priority_queue<ll> pq;
typedef priority_queue<ll, vector<ll>, greater<ll>> rpq;
const int INF = 1e9, MOD = 1e9 + 7, ohara = 1e6 + 10;
const ll LINF = 1e18;
#define rep(i, n) for (ll(i) = 0; (i) < (int)(n); (i)++)
#define rrep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrrep(i, a, b) for (ll i = (a); i >= (b); i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout << (x) << endl
#define doublecout(a) cout << fixed << setprecision(15) << a << endl;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
//------ Believe yourself as a genius!!!!!! ------
int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
// int dy[]={-1,0,1,-1,1,-1,0,1};int dx[]={-1,-1,-1,0,0,1,1,1};
string alph("abcdefghijklmnopqrstuvwxyz"), s;
ll n, cnt, ans, a[ohara], b[ohara], c, d, tmp, m, h, w, x, y, sum, k, q;
ll color[ohara];
V g[ohara];
bool dfs(ll v, ll c) {
color[v] = c;
rep(i, Size(g[v])) {
if (color[g[v][i]] == c) return false;
if (color[g[v][i]] == 0 && !dfs(g[v][i], -c)) return false;
}
return true;
}
int main(void) {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
rep(i, m) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
g[a[i]].p_b(b[i]);
g[b[i]].p_b(a[i]);
}
int ok = 1;
rep(i, n) {
if (color[i] == 0) {
if (!dfs(i, 1)) {
ok = 0;
break;
}
}
if (!ok) break;
}
if (!ok) {
ans = n * (n - 1) / 2;
} else {
ll cou1 = 0, cou2 = 0;
rep(i, n) {
if (color[i] == 1)
cou1++;
else
cou2++;
}
ans = cou1 * cou2;
}
Cout(ans - m);
return 0;
} | #include <bits/stdc++.h>
#define ri register
#define int long long
using namespace std; const int N=210;
inline int read()
{
int s=0, w=1; ri char ch=getchar();
while(ch<'0'||ch>'9') { if(ch=='-') w=-1; ch=getchar(); }
while(ch>='0'&&ch<='9') s=(s<<3)+(s<<1)+(ch^48), ch=getchar();
return s*w;
}
int n,book[N],g[N];
int f[N][N],res;
struct Node { int x,y; }a[N],b[N];
int DFS(int x)
{
for(ri int i=1;i<=n;i++)
{
if(!book[i]&&f[x][i])
{
book[i]=1;
if(g[i]==-1 || DFS(g[i]))
{
g[i]=x;
return 1;
}
}
}
return 0;
}
signed main()
{
n=read();
for(ri int i=1;i<=n;i++) a[i].x=read(), a[i].y=read();
for(ri int i=1;i<=n;i++) b[i].x=read(), b[i].y=read();
for(ri int i=1;i<=n;i++)
for(ri int j=1;j<=n;j++)
if(a[i].x<b[j].x && a[i].y<b[j].y) f[i][j]=1;
memset(g,-1,sizeof(g));
for(ri int i=1;i<=n;i++)
{
memset(book,0,sizeof(book));
if(DFS(i)) res++;
}
printf("%lld\n",res);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
typedef pair<ll, ll> P;
#define bit(n) (1LL << (n))
//#define int long long
#define all(v) v.begin(), v.end()
#define sortAl(v) sort(all(v))
#define sortAlr(v) \
sort(v.begin(), v.end()); \
reverse(v.begin(), v.end())
#define rep(i, n) for (ll i = 0; i < n; i++)
#define REP(i, n) for (ll i = 1; i < n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORm(i, m) for (auto i = m.begin(); i != m.end(); i++)
template <class T>
inline void chmax(T &a, T b) {
a = std::max(a, b);
}
template <class T>
inline void chmin(T &a, T b) {
a = std::min(a, b);
}
#define mod (ll)(1e9 + 7)
#define INF LLONG_MAX
ll bridge_dp[9][2] = {};
void create_bridge_dp() {
bridge_dp[0][0] = 1;
bridge_dp[1][0] = 1;
for (int i = 2; i <= 8; i++) {
// 横線を引かない
bridge_dp[i][0] = bridge_dp[i - 1][0] + bridge_dp[i - 1][1];
// 横線を引けるのは左に横線がない場合
bridge_dp[i][1] = bridge_dp[i - 1][0];
}
}
ll way_bridge(ll n) {
if (n <= 0) {
return 1;
}
return bridge_dp[n][0] + bridge_dp[n][1];
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll h, w, k;
cin >> h >> w >> k;
create_bridge_dp();
vvll dp(h + 1, vll(w + 2));
dp[0][1] = 1;
rep(y, h) {
REP(x, w + 1) {
dp[y + 1][x] = dp[y][x] * way_bridge(x - 1) * way_bridge(w - x);
dp[y + 1][x] += dp[y][x - 1] * way_bridge(x - 2) * way_bridge(w - x);
dp[y + 1][x] += dp[y][x + 1] * way_bridge(x - 1) * way_bridge(w - x - 1);
dp[y + 1][x] %= mod;
}
}
cout << dp[h][k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define M_PI 3.14159265358979323846 // pi
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> t3;
#define rep(a,n) for(ll a = 0;a < n;a++)
static const ll INF = 1e15;
static const ll mod = 1e9+7;
template<typename T>
static inline void chmin(T& ref, const T value) {
if (ref > value) ref = value;
}
template<typename T>
static inline void chmax(T& ref, const T value) {
if (ref < value) ref = value;
}
int main() {
ll n, m, d;
cin >> n >> m >> d;
{
ull b = n;
if (d != 0) {
b = d;
b += max(0LL, 2 * (n - d - (d + 1 - 1) ));
b += n - max(d, (n - d + 1 - 1));
}
b *= m - 1;
double ans = (double)b / n / n;
cout << fixed << setprecision(10);
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define MAX 2000005
#define MOD 1000000007
#define MOD2 998244353
#define pb push_back
#define mp make_pair
#define pii pair<ll,ll>
#define vi vector<ll>
#define vp vector<pii>
#define all(v) v.begin(),v.end()
#define sz(x) (ll)x.size()
#define F first
#define S second
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define ROF(i,a,b) for(ll i=a;i>=b;--i)
#define trace(x) cerr<<#x<<": "<<x<<'\n';
typedef long long ll;
using namespace std;
//using namespace __gnu_pbds;
//#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
ll mexp(ll a, ll b){
ll ans=1;
a%=MOD;
while(b){
if(b&1) ans=ans*a%MOD;
b>>=1;
a=a*a%MOD;
}
return ans;
}
const int N = 100005;
bool cmp1(pair<int,pair<int,int>>a, pair<int,pair<int,int>>b){
return a.S.F<b.S.F;
}
bool cmp2(pair<int,pair<int,int>>a, pair<int,pair<int,int>>b){
return a.S.S<b.S.S;
}
pair<int,pair<int,int>>c[N];
int par[N],siz[N];
int find(int x){
while(par[x]!=x){
x=par[x];
}
return x;
}
void un(int a,int b){
a=find(a);
b=find(b);
if(siz[a]<siz[b]){
par[a]=par[b];
siz[b]+=siz[a];
}
else{
par[b]=par[a];
siz[a]+=siz[b];
}
}
int main(){
IOS
int n;
cin>>n;
FOR(i,1,n+1){
par[i]=i;
siz[i]=1;
c[i].F=i;
cin>>c[i].S.F>>c[i].S.S;
}
vector<pair<int,pair<int,int>>>v;
sort(c+1,c+n+1,cmp1);
FOR(i,1,n){
v.pb(mp(c[i+1].S.F-c[i].S.F,mp(c[i].F,c[i+1].F)));
}
sort(c+1,c+n+1,cmp2);
FOR(i,1,n){
v.pb(mp(c[i+1].S.S-c[i].S.S,mp(c[i].F,c[i+1].F)));
}
sort(all(v));
int cnt=0;
int i=0;
ll ans=0;
while(cnt<n-1){
int x=find(v[i].S.F),y=find(v[i].S.S);
if(x==y){
i++;
continue;
}
un(x,y);
ans+=v[i].F;
i++;
cnt++;
}
cout<<ans;
cerr<<"Time: "<<1.0/CLOCKS_PER_SEC<<" ms"<<endl;
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; // pair(coordinate, index)
struct Edge {
ll from, to, cost;
Edge(){}
Edge(ll from, ll to, ll cost):from(from),to(to),cost(cost){}
};
bool comp(const Edge &e1, const Edge &e2) {
return e1.cost<e2.cost;
}
class union_find {
private:
vector<ll> par;
vector<ll> ran;
vector<ll> m_size;
public:
union_find(int n);
int find(int x);
void unite(int x, int y);
bool same(int x, int y);
ll size(int x);
};
union_find::union_find(int n){
par.resize(n);
iota(par.begin(), par.end(), 0);
ran.resize(n, 0);
m_size.resize(n, 1);
};
int union_find::find(int x) {
if (par[x] == x) return x;
else return par[x] = find(par[x]);
};
void union_find::unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (ran[x] < ran[y]) swap(x,y);
par[y] = x;
m_size[x] += m_size[y];
if (ran[x]==ran[y]) ran[x]++;
};
ll union_find::size(int x) {
return m_size[find(x)];
}
bool union_find::same(int x, int y) {
return (find(x) == find(y));
};
vector<Edge> g;
int V;
ll kruskal() {
sort(g.begin(), g.end(), comp);
union_find uf(V+1);
ll res = 0ll;
for (auto &&e: g) {
if (!uf.same(e.from,e.to)) {
uf.unite(e.from,e.to);
res+=e.cost;
}
}
return res;
}
int main(int argc, char const *argv[]) {
cin>>V;
vector<P> X, Y;
rep(i,V) {
ll x,y; cin>>x>>y;
X.emplace_back(x,i); Y.emplace_back(y,i);
}
sort(X.begin(), X.end());
sort(Y.begin(), Y.end());
rep(i,V-1) {
ll from = X[i].second; ll to = X[i+1].second;
ll cost = X[i+1].first-X[i].first;
g.emplace_back(from,to,cost);
from = Y[i].second; to = Y[i+1].second;
cost = Y[i+1].first-Y[i].first;
g.emplace_back(from,to,cost);
}
cout << kruskal() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s = to_string(n);
int ans = 0;
for(int i = 0; i < 3; i++){
if(s.at(i) == '7'){
ans = 1;
}
}
if(ans == 0){
cout << "No" << endl;
}
else{
cout << "Yes" << endl;
}
} | #include<iostream>
using namespace std;
int main (void)
{
int r;
cin>>r;
while(r>1)
{
if(r%10==7)
{
cout<<"Yes";return 0;
}
r=r/10;
}
cout<<"No";
} | 1 |
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
using namespace std;
const int maxn=1e5+5;
int fa[maxn];
int tot;
struct way{
int u,v;
long long w;
}edge[maxn*4];
struct node
{
int x,y,id;
}a[maxn];
int find(int x){return fa[x]==x?fa[x]:fa[x]=find(fa[x]);}
void link(int x,int y)
{
int tx=find(x),ty=find(y);
fa[ty]=tx;
}
bool cmp(way a,way b){return a.w<b.w;}
bool cmp1(node a,node b){return a.x<b.x;}
bool cmp2(node a,node b){return a.y<b.y;}
int main()
{
int m,n;
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
a[i].id=i;
scanf("%d %d",&a[i].x,&a[i].y);
}
sort(a+1,a+1+n,cmp1);
int cnt=0;
for(int i=1;i<n;i++)
{
cnt++;
edge[cnt].u=a[i].id;
edge[cnt].v=a[i+1].id;
edge[cnt].w=(long long)(a[i+1].x-a[i].x);
cnt++;
edge[cnt].u=a[i+1].id;
edge[cnt].v=a[i].id;
edge[cnt].w=(long long)(a[i+1].x-a[i].x);
}
sort(a+1,a+1+n,cmp2);
for(int i=1;i<n;i++)
{
cnt++;
edge[cnt].u=a[i].id;
edge[cnt].v=a[i+1].id;
edge[cnt].w=(long long)(a[i+1].y-a[i].y);
cnt++;
edge[cnt].u=a[i+1].id;
edge[cnt].v=a[i].id;
edge[cnt].w=(long long)(a[i+1].y-a[i].y);
}
for(int i=1;i<=n;i++) fa[i]=i;
sort(edge+1,edge+cnt+1,cmp);
for(int i=1;i<=cnt;i++)
{
if(find(edge[i].u)!=find(edge[i].v))
{
link(edge[i].u,edge[i].v);
tot=tot+edge[i].w;
}
}
cout<<tot<<endl;
return 0;
} | #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define MAX 2000005
#define MOD 1000000007
#define MOD2 998244353
#define pb push_back
#define mp make_pair
#define pii pair<ll,ll>
#define vi vector<ll>
#define vp vector<pii>
#define all(v) v.begin(),v.end()
#define sz(x) (ll)x.size()
#define F first
#define S second
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define ROF(i,a,b) for(ll i=a;i>=b;--i)
#define trace(x) cerr<<#x<<": "<<x<<'\n';
typedef long long ll;
using namespace std;
//using namespace __gnu_pbds;
//#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
ll mexp(ll a, ll b){
ll ans=1;
a%=MOD;
while(b){
if(b&1) ans=ans*a%MOD;
b>>=1;
a=a*a%MOD;
}
return ans;
}
const int N = 100005;
bool cmp1(pair<int,pair<int,int>>a, pair<int,pair<int,int>>b){
return a.S.F<b.S.F;
}
bool cmp2(pair<int,pair<int,int>>a, pair<int,pair<int,int>>b){
return a.S.S<b.S.S;
}
pair<int,pair<int,int>>c[N];
int par[N],siz[N];
int find(int x){
while(par[x]!=x){
x=par[x];
}
return x;
}
void un(int a,int b){
a=find(a);
b=find(b);
if(siz[a]<siz[b]){
par[a]=par[b];
siz[b]+=siz[a];
}
else{
par[b]=par[a];
siz[a]+=siz[b];
}
}
int main(){
IOS
int n;
cin>>n;
FOR(i,1,n+1){
par[i]=i;
siz[i]=1;
c[i].F=i;
cin>>c[i].S.F>>c[i].S.S;
}
vector<pair<int,pair<int,int>>>v;
sort(c+1,c+n+1,cmp1);
FOR(i,1,n){
v.pb(mp(c[i+1].S.F-c[i].S.F,mp(c[i].F,c[i+1].F)));
}
sort(c+1,c+n+1,cmp2);
FOR(i,1,n){
v.pb(mp(c[i+1].S.S-c[i].S.S,mp(c[i].F,c[i+1].F)));
}
sort(all(v));
int cnt=0;
int i=0;
ll ans=0;
while(cnt<n-1){
int x=find(v[i].S.F),y=find(v[i].S.S);
if(x==y){
i++;
continue;
}
un(x,y);
ans+=v[i].F;
i++;
cnt++;
}
cout<<ans;
cerr<<"Time: "<<1.0/CLOCKS_PER_SEC<<" ms"<<endl;
return 0;
} | 1 |
#include <iostream>
#include <memory>
#include <cmath>
constexpr int max_size()
{
return static_cast<int>(1e+6);
}
int insert(int* a, const int i, const int gear)
{
if (i < gear) {
return 0;
}
if (a[i - gear] <= a[i]) {
return 0;
}
std::swap(a[i - gear], a[i]);
return 1 + insert(a, i - gear, gear);
}
int insertion_sort(int* arr, const int n, const int gear)
{
int insert_count = 0;
for (int i = 0; i < n; i += gear) {
insert_count += insert(arr, i, gear);
}
return insert_count;
}
int pow(const int a, const int x) {
return x == 0 ? 1 : a * pow(a, x - 1);
}
void print(int* arr, const int n, const int i, char const delim) {
if (i == n - 1) {
std::cout << arr[i];
return;
}
std::cout << arr[i] << delim;
print(arr, n, i + 1, delim);
}
void print(int* arr, const int n, char const delim) {
int i = 0;
for (; i < n - 1; ++i) {
std::cout << arr[i] << delim;
}
std::cout << arr[i];
}
void shell_sort(int* arr, const int n) {
static const double log3 = std::log(3);
const int gear_index = static_cast<int>(std::log(2 * n + 1) / log3 - 1);
int gear = (pow(3, gear_index + 1) - 1) >> 1;
int gear_cache[100];
int cache_idx = 0;
int insert_count = 0;
for (; gear > 0; gear = (gear - 1) / 3) {
gear_cache[cache_idx] = gear;
for (int i = 0; i < gear; ++i) {
insert_count += insertion_sort(arr + i, n - i, gear);
}
++cache_idx;
}
std::cout << cache_idx << std::endl;
print(gear_cache, cache_idx, ' ');
std::cout << std::endl;
std::cout << insert_count << std::endl;
return;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
std::cin >> n;
constexpr int N = max_size();
const auto r = std::make_unique<int[]>(N);
for (int i = 0; i < n; ++i) {
std::cin >> r[i];
}
shell_sort(r.get(), n);
print(r.get(), n, '\n');
std::cout << std::endl;
return 0;
} | #include <iostream>
using namespace std;
int main(void){
int cnt=0,m=0,n,a[1000000],g[100]={0};
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
g[0]=1;
while(g[m]<n){
g[m+1]=3*g[m]+1;
m++;
}
if(n==1)
m=1;
for(int i=m-1;i>=0;i--){
for(int k=g[i];k<n;k++){
int v=a[k];
int j=k-g[i];
while(j>=0&&a[j]>v){
a[j+g[i]]=a[j];
j=j-g[i];
cnt++;
}
a[j+g[i]]=v;
}
}
cout<<m<<endl;
for(int i=m-1;i>0;i--)
cout<<g[i]<<" ";
cout<<g[0]<<endl;
cout<<cnt<<endl;
for(int i=0;i<n;i++)
cout<<a[i]<<endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define very_slow ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vec vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define inf 1e18
#define MAX 1e9
#define MIN -1e9
#define no_of_test(x) int x; cin>>x; while(x--)
//Actual Code Is At The Top
const int mod = 1e9 + 7;
int gcd(int a, int b)
{
if (b == 0) return a;
return gcd(b, a % b);
}
int binary_exponentation(int a, int b)
{
int ret = 1;
while (b)
{
if (b & 1) ret = (ret * a) % mod;
b >>= 1;
a = (a * a) % mod;
}
return ret;
}
int32_t main()
{
very_slow
// no_of_test(x)
{
int n;
cin>>n;
int r=0,k=0;
if(n>=500)
{
r=n/500;
n=n-(r*500);
}
if(n>=20)
{
k=n/5;
}
cout<<r*1000+k*5<<'\n';
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans=0;
for(int i=0;i<s.size()-1;i++){
if(s.at(i)=='A'&&s.at(i+1)=='C') ans++;
}
if(ans>=1) cout << "Yes";
else cout << "No";
} | 0 |
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <sstream>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#define rep(i, n) for(int i = 0; i < n; i ++)
#define COUNT(i, n) for(int i = 1; i <= n; i ++)
#define ITER(c) __typeof((c).begin())
#define each(c, it) for(ITER(c) it =(c).begin(); it!=(c).end(); it++)
#define ALL(c) c.begin(), c.end()
#define mp make_pair
#define pb push_back
#define MEMSET(v, h) memset((v), h, sizeof(v))
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
const int INF = 1 << 24;
int main(void){
for(int n, m, s; s = 0, cin >> n >> m, n; cout << s << endl){
priority_queue<int> p;
rep(i, n){
int in; cin >> in;
p.push(in);
}
COUNT(i, n){
if(i % m) s += p.top();
p.pop();
}
}
return 0;
} | #include <bits/stdc++.h>
#define r(i,n) for(i=0;i<n;i++)
using namespace std;
int main(){
int a,b,i;
while(cin>>a>>b,a){
int c[a],s=0,k=0,p=0;
r(i,a){cin>>c[i];p+=c[i];}
sort(c,c+a);
for(i=a-1;i>=0;i--){
k++;
if(k==b){
s+=c[i];
k=0;
}
}
cout<<p-s<<endl;;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string sa;
cin >> sa;
int chain = 0;
int ma = 0;
for (char j : sa){
if (j == 'R'){
chain ++;
}else chain = 0;
ma = max(ma,chain);
}
cout << ma << endl;
} | #include <bits/stdc++.h>
#define INF INT_MAX
#define ll long long
#define ull unsigned long long
#define rep(i,n) for(ll i=0; i<n; ++i)
#define FOR(i, s, e) for(ll i=s; i<e; ++i)
#define MOD 1000000007
using namespace std;
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() {
cin.tie(0);
ios::sync_with_stdio(false);
string S; cin >> S;
if(S == "RRS" || S == "SRR") cout << 2 << endl;
else if(S == "RRR") cout << 3 << endl;
else if(S == "SSS") cout << 0 << endl;
else cout << 1 << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll N,K;
cin>>N>>K;
ll cnt=1;
rep(i,N){
if(cnt<K){
cnt*=2;
}
else{
cnt+=K;
}
}
cout<<cnt<<endl;
}
| #include <iostream>
#include <bits/stdc++.h>
#define ll long long int
#define d 1000000007
using namespace std;
int main()
{
int t;
t=1;
while(t--)
{
int n,k;
cin >> n;
cin >> k;
int result=1;
while(n>0)
{
result=min(result*2,result+k);
n--;
}
cout << result << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(long long i=0;i<(long long)(n);i++)
#define REP(i,k,n) for(long long i=k;i<(long long)(n);i++)
#define all(a) a.begin(),a.end()
#define pb push_back
#define eb emplace_back
#define lb(v,k) (lower_bound(all(v),k)-v.begin())
#define ub(v,k) (upper_bound(all(v),k)-v.begin())
#define fi first
#define se second
#define pi M_PI
#define PQ(T) priority_queue<T>
#define SPQ(T) priority_queue<T,vector<T>,greater<T>>
#define dame(a) {out(a);return 0;}
#define decimal cout<<fixed<<setprecision(15);
typedef long long ll;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> PP;
typedef tuple<ll,ll,ll,ll> PPP;
typedef multiset<ll> S;
using vi=vector<ll>;
using vvi=vector<vi>;
using vvvi=vector<vvi>;
using vp=vector<P>;
using vvp=vector<vp>;
using vb=vector<bool>;
using vvb=vector<vb>;
const ll inf=1001001001001001;
const int INF=1001001001;
const int mod=1000000007;
const double eps=1e-10;
template<class T> bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<class T> bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<class T> void out(T a){cout<<a<<'\n';}
template<class T> void outp(T a){cout<<'('<<a.fi<<','<<a.se<<')'<<'\n';}
template<class T> void outvp(T v){rep(i,v.size())cout<<'('<<v[i].fi<<','<<v[i].se<<')';cout<<'\n';}
template<class T> void outvvp(T v){rep(i,v.size())outvp(v[i]);}
template<class T> void outv(T v){rep(i,v.size()){if(i)cout<<' ';cout<<v[i];}cout<<'\n';}
template<class T> void outvv(T v){rep(i,v.size())outv(v[i]);}
template<class T> bool isin(T x,T l,T r){return (l)<=(x)&&(x)<=(r);}
template<class T> void yesno(T b){if(b)out("yes");else out("no");}
template<class T> void YesNo(T b){if(b)out("Yes");else out("No");}
template<class T> void YESNO(T b){if(b)out("YES");else out("NO");}
template<class T> void noyes(T b){if(b)out("no");else out("yes");}
template<class T> void NoYes(T b){if(b)out("No");else out("Yes");}
template<class T> void NOYES(T b){if(b)out("NO");else out("YES");}
void outs(ll a,ll b){if(a>=inf-100)out(b);else out(a);}
ll gcd(ll a,ll b){if(b==0)return a;return gcd(b,a%b);}
ll modpow(ll a,ll b){a%=mod;if(b==0)return 1;if(b&1)return a*modpow(a,b-1)%mod;ll k=modpow(a,b/2);return k*k%mod;}
vi level,memo;
vvi v;
ll n;
void bfs(ll s){
level=vi(n,inf);
queue<P> q;
q.push(P(s,0));
level[s]=0;
while(!q.empty()){
auto t=q.front();q.pop();
rep(i,n)if(v[t.fi][i]){
if(chmin(level[i],t.se+1))q.push(P(i,t.se+1));
}
}
}
ll dfs(ll i,ll t,ll f){
if(i==t)return f;
REP(j,memo[i],n){
memo[i]++;
if(v[i][j]==0||level[i]>=level[j])continue;
ll d=dfs(j,t,min(f,v[i][j]));
if(d>0){
v[i][j]-=d;
v[j][i]+=d;
return d;
}
}
return 0;
}
ll max_flow(ll s,ll t){
ll flow=0;
while(true){
bfs(s);
if(level[t]==inf)return flow;
memo=vi(n);
while(true){
ll f=dfs(s,t,inf);
if(f==0)break;
flow+=f;
}
}
return flow;
}
int main(){
cin>>n;
v=vvi(n*2+2,vi(n*2+2));
vp point(2*n);
rep(i,2*n)cin>>point[i].fi>>point[i].se;
rep(i,n)rep(j,n)if(point[i].fi<=point[j+n].fi&&point[i].se<=point[j+n].se){
v[i+1][j+n+1]++;
}
rep(i,n)v[0][i+1]++;
rep(i,n)v[i+n+1][n*2+1]++;
n=n*2+2;
outs(max_flow(0,n-1),-1);
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INFint = 1e9+1;
const ll INFll = (ll)1e18+1;
ll MOD=1e9+7;
int main(){
int N;
cin>>N;
vector<pair<int,int>> a(N),b(N);
for(int i(0);i<N;i++){
cin>>a[i].second>>a[i].first;
}
for(int i(0);i<N;i++){
cin>>b[i].first>>b[i].second;
}
sort(a.rbegin(),a.rend());
sort(b.begin(),b.end());
int ans(0);
int used[100] = {0};
for(int i(0);i<N;i++){
for(int j(0);j<N;j++){
if(a[j].second < b[i].first){
if(used[j] == 0 && a[j].first < b[i].second){
used[j] = 1;
ans++;
break;
}
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include<stdio.h>
#include<algorithm>
#define reg register
#define ri reg int
#define rep(i, x, y) for(ri i = x; i <= y; ++i)
#define nrep(i, x, y) for(ri i = x; i >= y; --i)
#define DEBUG 1
#define ll long long
#define max(i, j) (i) > (j) ? (i) : (j)
#define min(i, j) (i) < (j) ? (i) : (j)
struct IO {
#define MAXSIZE (1 << 20)
#define isdigit(x) (x >= '0' && x <= '9')
char buf[MAXSIZE], *p1, *p2;
char pbuf[MAXSIZE], *pp;
#if DEBUG
#else
IO() : p1(buf), p2(buf), pp(pbuf) {}
~IO() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
#endif
inline char gc() {
#if DEBUG
return getchar();
#endif
if(p1 == p2)
p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin);
return p1 == p2 ? ' ' : *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
register double tmp = 1;
register bool sign = 0;
x = 0;
register char ch = gc();
for(; !isdigit(ch); ch = gc())
if(ch == '-') sign = 1;
for(; isdigit(ch); ch = gc())
x = x * 10 + (ch - '0');
if(ch == '.')
for(ch = gc(); isdigit(ch); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if(sign) x = -x;
}
inline void read(char *s) {
register char ch = gc();
for(; blank(ch); ch = gc());
for(; !blank(ch); ch = gc())
*s++ = ch;
*s = 0;
}
inline void read(char &c) {
for(c = gc(); blank(c); c = gc());
}
inline void push(const char &c) {
#if DEBUG
putchar(c);
#else
if(pp - pbuf == MAXSIZE) {
fwrite(pbuf, 1, MAXSIZE, stdout);
pp = pbuf;
}
*pp++ = c;
#endif
}
template <class T>
inline void write(T x) {
if(x < 0) {
x = -x;
push('-');
}
static T sta[35];
T top = 0;
do{
sta[top++] = x % 10;
x /= 10;
}while(x);
while(top)
push(sta[--top] + '0');
}
template <class T>
inline void write(T x, char lastChar) {
write(x);
push(lastChar);
}
} io;
int a[110], n, ans;
int main() {
io.read(n);
rep(i, 1, n * 2) io.read(a[i]);
std::sort(a + 1, a + 2 * n + 1);
rep(i, 1, n) ans += a[2 * i - 1];
io.write(ans);
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int n,res=0;
scanf("%d",&n);
n*=2;
vector<int>arr(n);
for(int i=0;i<n;i++)
{
scanf("%d",&arr[i]);
}
sort(arr.begin(),arr.end());
for(int i=0;i<n;i+=2)
{
res+=arr[i];
}
printf("%d",res);
}
| 1 |
#include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
//ll mod = 998244353;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
string s;
cin >> s;
int n = s.size();
if (n != 26) {
vector<bool> flg(26, false);
rep(i, n) flg[s[i]-'a'] = true;
cout << s;
rep(i, 26) {
if (!flg[i]) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
}
else {
string t = s;
if (!next_permutation(t.begin(), t.end())) {
cout << -1 << endl;
return 0;
}
rep(i, n) {
cout << t[i];
if (t[i] != s[i]) {
cout << endl;
break;
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#include <stdlib.h>
int main() {
string B;
cin >> B;
vector<char>vec(B.size());
for(int i=0;i<B.size();i++){
vec.at(i)=B.at(i);
}
int count=99999;
for(int i=2 ;i<B.size();i++){
int A=vec.at(i-2)- '0',B=vec.at(i-1)- '0',C=vec.at(i)- '0';
int D;
D=100*A+10*B+C;
D=abs(753-D);
count=min(D,count);
}
cout << count <<endl;
} | 0 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#define N 100005
using namespace std;
struct st{
int l, r;
} a[N];
int n, mx, fl[N], fr[N], bl[N], br[N];
bool cmp(st p, st q) {
if (p.r != q.r) return p.r < q.r;
else return p.l < q.l;
}
int main()
{
int i;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%d %d", &a[i].l, &a[i].r);
}
sort(a, a + n, cmp);
fl[0] = a[0].l; fr[0] = a[0].r;
for (i = 1; i < n; i++) {
fl[i] = max(fl[i - 1], a[i].l);
fr[i] = min(fr[i - 1], a[i].r);
}
bl[n - 1] = a[n - 1].l; br[n - 1] = a[n - 1].r;
for (i = n - 2; i >= 0; i--) {
bl[i] = max(bl[i + 1], a[i].l);
br[i] = min(br[i + 1], a[i].r);
}
for (i = 0; i < n; i++) {
mx = max(mx, a[i].r - a[i].l + 1 + max(0, fr[n - 1] - fl[n - 1] + 1));
}
for (i = 0; i < n - 1; i++) {
mx = max(mx, max(0, fr[i] - fl[i] + 1) + max(0, br[i + 1] - bl[i + 1] + 1));
}
cout << mx << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<pair<int,int>> ab(n),cd(n);
for(int i=0;i<n;++i){
int a,b;
cin >> a >> b;
ab[i]=make_pair(b,a);
}
for(int i=0;i<n;++i){
int c,d;
cin >> c >> d;
cd[i]=make_pair(c,d);
}
sort(ab.begin(),ab.end(),greater<pair<int,int>>());
sort(cd.begin(),cd.end());
vector<bool> f(n,false);
int cnt=0;
for(int i=0;i<n;++i){
int c=cd[i].first;
int d=cd[i].second;
for(int j=0;j<n;++j){
int b=ab[j].first;
int a=ab[j].second;
if(f[j])continue;
if(a<c && b<d){
f[j]=true;
cnt++;
break;
}
}
}
//int cnt=0;
//for(int i=0;i<n;++i)if(f[i])cnt++;
cout << cnt << endl;
return 0;
}
| 0 |
#include <cstdio>
#include <cstring>
using namespace std;
const int mod = 998244353;
char s[301];
int a[300];
int dp[301][301][301][4];
int main() {
int n, k, i, j, l, r;
long long ans = 0;
scanf("%s %d", s, &k);
n = strlen(s);
for (i = 0; i < n; i++) a[i] = s[i] - '0';
dp[0][0][0][0] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
for (l = 0; l < n && l <= k; l++) {
for (r = 0; r < 4; r++) {
if (dp[i][j][l][r] == 0) continue;
if (a[i] == 0) {
dp[i + 1][j][l][0] += dp[i][j][l][r];
if (dp[i + 1][j][l][0] >= mod) dp[i + 1][j][l][0] -= mod;
if (i > 0 && a[i - 1] == 1 && r >= 2) continue;
dp[i][j + 1][l + 1][0] += dp[i][j][l][r];
if (dp[i][j + 1][l + 1][0] >= mod) dp[i][j + 1][l + 1][0] -= mod;
} else {
dp[i + 1][j][l][r | 1] += dp[i][j][l][r];
if (dp[i + 1][j][l][r | 1] >= mod) dp[i + 1][j][l][r | 1] -= mod;
if (j > 0 && (r & 1) == 0) {
dp[i + 1][j - 1][l][r | 2] += dp[i][j][l][r];
if (dp[i + 1][j - 1][l][r | 2] >= mod) dp[i + 1][j - 1][l][r | 2] -= mod;
}
}
}
}
}
}
for (i = 0; i <= k && i <= n; i++) {
for (j = 0; j < 4; j++) {
ans += dp[n][0][i][j];
}
}
printf("%lld\n", ans % mod);
return 0;
}
| //#include<bits/stdc++.h>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
const int cm = 1 << 17;
char cn[cm], * ci = cn + cm, ct;
inline char getcha() {
if (ci - cn == cm) { fread(cn, 1, cm, stdin); ci = cn; }
return *ci++;
}
inline int getint() {
int A = 0;
if (ci - cn + 16 > cm) while ((ct = getcha()) >= '0') A = A * 10 + ct - '0';
else while ((ct = *ci++) >= '0') A = A * 10 + ct - '0';
return A;
}
int main() {
//cin.tie(0);
//ios::sync_with_stdio(false);
int N = getint();
int A[200000];
ll goukei = 0;
rep(i, N) goukei += (A[i] = getint());
ll kotae = 1e18;
int q = 1, s = 3;
ll PQ = A[0] - A[1];
ll RS = -goukei + A[2] + A[0] + A[1] + A[2] ;
ll diff = -goukei + A[0] + A[1] + A[0] + A[1];
for (int r = 2; r < N - 1; r++) {
while (abs(PQ) > abs(PQ + 2 * A[q])) {
PQ += 2 * A[q];
q++;
}
while (abs(RS) > abs(RS + 2 * A[s])) {
RS += 2 * A[s];
s++;
}
ll kari = max(abs(diff) + abs(PQ) + abs(RS), max(abs(PQ), abs(RS)) * 2);
kotae = min(kotae, kari);
PQ -= A[r];
RS -= A[r];
diff += 2 * A[r];
}
printf("%lld", kotae / 2);
Would you please return 0;
} | 0 |
#include <bits/stdc++.h>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
ll MX = 1e18;
int n,k;
cin >> n >> k;
vector<int> neg,pos;
rep(i,n){
int temp;cin >> temp;
if(temp == 0) k--;
else if(temp < 0) neg.push_back(temp);
else pos.push_back(temp);
}
sort(neg.begin(),neg.end(),greater<int>());
if(k <= 0){
cout << 0 << endl;
return 0;
}
int s = pos.size();
int t = neg.size();
ll ans = MX;
ll total = 0;
if(s >= k){
total = pos[k-1];
ans = min(ans,total);
}
if(t >= k){
total = abs(neg[k-1]);
ans = min(ans,total);
}
for(int i = max(0,k-t-1);i<=min(s-1,k-2);i++){
total = 2*abs(neg[k-i-2]) + pos[i];
ans = min(ans,total);
}
for(int i = max(0,k-s-1);i<=min(t-1,k-2);i++){
total = 2*pos[k-i-2] + abs(neg[i]);
ans = min(ans,total);
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
using ll = long long;
int main() {
int n, k; cin >> n >> k;
V<ll> v(n);
for(int i = 0; i < n; i++) cin >> v[i];
ll ans = 1e9;
for(int l = 0; l <= n - k; l++){
ll r = l + k - 1;
ans = min(ans, abs(v[l]) + abs(v[l] - v[r]));
ans = min(ans, abs(v[r]) + abs(v[r] - v[l]));
}
cout << ans << endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n=1;
int a = 0;
int f = 0;
int quest[10000] = { 1 };
double ans[10000];
int checkc = 0;
int i = 4;
double check[3] = { 1, 2, 4 };
do{
cin >> quest[a];
a++;
} while (quest[a-1] != 0);
while (a > f+1){
switch (quest[f]){
case 1:
ans[f] = 1;
break;
case 2:
ans[f] = 2;
break;
case 3:
ans[f] = 4;
break;
default:
while (quest[f] >= i){
ans[f] = check[0] + check[1] + check[2];
i++;
check[0] = check[1];
check[1] = check[2];
check[2] = ans[f];
}
}
ans[f] = ans[f] / 3650;
checkc = (int)(ans[f]);
if (ans[f] > (double)(checkc)){
checkc++;
}
if (ans[f] != 0){
cout << checkc << endl;
}
else{
cout << endl;
}
f++;
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <queue>
#include <stack>
#include <complex>
#include <utility>
#include <set>
#include <cmath>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pi acos(-1)
#define all(v) v.begin(),v.end()
#define EPS (1e-10)
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) (EQ((a).real(),(b).real()) && EQ((a).imag(),(b).imag()))
using namespace std;
typedef pair<int,int> point;
typedef complex<double> P;
typedef long long ll;
const double eps = 1e-8;
const double INF = 1e12;
double dot(P a,P b){
return a.real()*b.real()+a.imag()*b.imag();
}
double cross(P a,P b){
return a.real()*b.imag()-a.imag()*b.real();
}
bool is_orthogonal(P a1,P a2,P b1,P b2){
return EQ(dot(a1-a2,b1-b2),0.0);
}
bool is_parallel(P a1,P a2,P b1,P b2){
return EQ(cross(a1-a2,b1-b2),0.0);
}
bool is_point_on_line(P a,P b,P c){
return EQ(cross(b-a,c-a),0.0);
}
bool is_point_on_linesegment3(P a,P b,P c){
//|a-c| + |c-b|<=|a-b| ???????????????
return (abs(a-c)+abs(c-b)<abs(a-b)+EPS);
}
double distance_l_p(P a,P b,P c){
return abs(cross(b-a,c-a))/abs(b-a);
}
double distance_ls_p(P a,P b,P c){
if(dot(b-a,c-a)<EPS)return abs(c-a);
if(dot(a-b,c-b)<EPS)return abs(c-b);
return abs(cross(b-a,c-a))/abs(b-a);
}
int main(){
long long dt[50];
rep(i,50)dt[i]=0;
dt[1]=1;
dt[2]=1;
dt[3]=1;
rep(i,30){
dt[i+1]+=dt[i];
dt[i+2]+=dt[i];
dt[i+3]+=dt[i];
}
int n;
while(cin>>n,n){
if(dt[n]%3650!=0)cout<<dt[n]/3650+1<<endl;
else cout<<dt[n]/3650<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
//type
#define ll long long
typedef pair<int, int> P;
//定数
#define INF 1000000000000 //10^12:∞
#define MOD 1000000007 //10^9+7:合同式の法
#define MAXR 100000 //10^5:配列の最大のrange
//略記
#define PB push_back //挿入
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素
#define Z class
// OTHER
// xの二乗を返す (関数テンプレート版)
template <typename T>
T square(T x) { return x * x; }
#define chmax(x, y) (x = max(x, y))
#define chmin(x, y) (x = min(x, y))
// loop
#define rep(i, n) for (int i = 0; i < (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 FORA(i, I) for (const auto &i : I)
// vector
#define ALL(x) x.begin(), x.end()
// output
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n", (x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define ln cout << '\n'
template <Z A>
void pr(A a)
{
cout << a;
ln;
}
template <Z A, Z B>
void pr(A a, B b)
{
cout << a << ' ';
}
int ans = 0;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
int main()
{
string a, b, c, n, x, y;
cin >> a >> b >> c;
// cin >> a >> b >> c;
if ((a[a.length() - 1] == b[0]) && (b[b.length() - 1] == c[0]))
YES();
else
NO();
return 0;
} | #include<stdio.h>
int main(){
char a[100];
scanf("%[^\n]", a);
int ctr = 0;
for(int i= 0; a[i] != '\0'; i++){
if(a[i] == ' '){
if(a[i - 1] == a[i + 1]){
ctr++;
}
}
}
if(ctr == 2){
printf("YES\n");
}
else{
printf("NO\n");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int H,W,K;
const int MOD = 1e9+7;
vector<int> change;
vector<vector<int>> next_w;
void rec(int w){
if(w == W-1){
vector<int> n(W,0);
REP(i,W) n[i] = i;
REP(i,W-1) if(change[i]==1) swap(n[i],n[i+1]);
REP(i,W){
next_w[n[i]][i]++;
}
return;
}
change[w] = 0;
rec(w+1);
change[w] = 1;
if(w+2 < W) change[w+1]=0, rec(w+2);
if(w+2 == W) rec(w+1);
}
int main() {
cin >> H >> W >> K;
next_w.assign(W, vector<int>(W,0));
change.assign(W-1,0);
rec(0);
vector<vector<ll>> ans(H+1, vector<ll>(W,0));
ans[0][0] = 1;
REP(i,H){
REP(j,W){
if(j-1>=0){
ans[i+1][j-1] += ans[i][j] * next_w[j][j-1];
ans[i+1][j-1] %= MOD;
}
ans[i+1][j] += ans[i][j] * next_w[j][j];
ans[i+1][j] %= MOD;
if(j+1<=W-1){
ans[i+1][j+1] += ans[i][j] * next_w[j][j+1];
ans[i+1][j+1] %= MOD;
}
}
}
cout << ans[H][K-1] << endl;
return 0;
} | #include<cstdio>
using ull = unsigned long long;
const static int MOD = 1000000007;
const static int MAX_H = 100;
const static int MAX_W = 8;
ull dp[MAX_H+1][MAX_W], fibonacci[8] = {1, 1, 2, 3, 5, 8, 13, 21};
int main(){
unsigned H, W, K;
scanf("%u %u %u", &H, &W, &K);
if(W == 1){
printf("1\n");
return 0;
}
K--;
dp[0][0] = 1;
for (size_t i = 1; i <= H; i++){
dp[i][0] = (dp[i-1][0]*fibonacci[W-1] + dp[i-1][1]*fibonacci[W-2]) %MOD;
for (size_t j = 1; j < W-1; j++){
dp[i][j] = (dp[i-1][j-1]*fibonacci[j-1]*fibonacci[W - j - 1] + dp[i-1][j]*fibonacci[j]*fibonacci[W - j - 1] + dp[i-1][j+1]*fibonacci[j]*fibonacci[W - j - 2]) %MOD;
}
dp[i][W-1] = (dp[i-1][W-1]*fibonacci[W-1] + dp[i-1][W-2]*fibonacci[W-2]) %MOD;
}
printf("%llu\n", dp[H][K]);
return 0;
} | 1 |
//#define NDEBUG
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <utility>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
struct rep {
struct itr {
usize i;
constexpr itr(const usize i) noexcept : i(i) {}
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
const itr f, l;
constexpr rep(const usize f, const usize l) noexcept
: f(std::min(f, l)), l(l) {}
constexpr auto begin() const noexcept { return f; }
constexpr auto end() const noexcept { return l; }
};
struct revrep {
struct itr {
usize i;
constexpr itr(const usize i) noexcept : i(i) {}
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
const itr f, l;
constexpr revrep(const usize f, const usize l) noexcept
: f(l - 1), l(std::min(f, l) - 1) {}
constexpr auto begin() const noexcept { return f; }
constexpr auto end() const noexcept { return l; }
};
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) noexcept {
return a < b ? b - a : a - b;
}
template <class T> void chmin(T &a, const T &b) noexcept {
if (b < a)
a = b;
}
template <class T> void chmax(T &a, const T &b) noexcept {
if (a < b)
a = b;
}
template <class F> class rec_lambda {
F f;
public:
rec_lambda(F &&f) : f(std::move(f)) {}
template <class... Args> auto operator()(Args &&... args) const {
return f(*this, std::forward<Args>(args)...);
}
};
template <class F> auto make_rec(F &&f) { return rec_lambda<F>(std::move(f)); }
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
constexpr char eoln = '\n';
} // namespace n91
#include <cassert>
namespace n91 {
void main_() {
/*
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
//*/
constexpr usize Inf = std::numeric_limits<usize>::max() / 2;
const usize n = scan<usize>();
const usize m = scan<usize>();
auto g = md_vec(n, n, Inf);
for (const usize i : rep(0, m)) {
const usize a = scan<usize>() - 1;
const usize b = scan<usize>() - 1;
g[a][b] = 1;
}
for (const usize i : rep(0, n)) {
for (const usize j : rep(0, n)) {
for (const usize k : rep(0, n)) {
chmin(g[j][k], g[j][i] + g[i][k]);
}
}
}
usize st = 0;
for (const usize i : rep(0, n)) {
if (g[i][i] < g[st][st]) {
st = i;
}
}
if (g[st][st] >= Inf) {
std::cout << "-1" << eoln;
return;
}
std::vector<usize> ans;
usize v = st;
do {
for (const usize i : rep(0, n)) {
if (g[v][i] == 1 && ans.size() + 1 + g[i][st] == g[st][st]) {
ans.push_back(i);
v = i;
break;
}
}
} while (ans.size() != g[st][st] - 1);
ans.push_back(st);
std::cout << ans.size() << eoln;
for (const auto e : ans) {
std::cout << e + 1 << eoln;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#define pii pair<int,int>
#define F first
#define S second
using namespace std;
const int MAX_N = 1e4+10;
const int INF = 1e9+10;
typedef long long ll;
vector <int> vec[MAX_N];
bool ans[MAX_N];
int dp[MAX_N],depth[MAX_N];
void dfs(int v,int cnt,int p){
depth[v]=cnt+1;
dp[v]=depth[v];
int nd=0;
for(int u:vec[v]){
if(u==p)
continue;
if(dp[u])
dp[v]=min(dp[v],depth[u]);
else{
dfs(u,cnt+1,v);
dp[v]=min(dp[v],dp[u]);
if(dp[u]>=depth[v])
ans[v]=true;
nd++;
}
}
if(p==-1&&nd<2)
ans[v]=false;
}
int main(){
int n,m;
cin>>n>>m;
for(int i=0;i<m;i++){
int a,b;
cin>>a>>b;
vec[a].push_back(b);
vec[b].push_back(a);
}
dfs(0,0,-1);
for(int i=0;i<n;i++)
if(ans[i])
cout<<i<<endl;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define INF (1<<29)
int G[101][101];
int n, k;
void init(){
for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++){
G[i][j] = INF;
if(i == j) G[i][j] = 0;
}
}
}
int main(){
while(cin >> n >> k){
if(n == 0 && k == 0) break;
init();
int op, a, b, e;
for(int cs = 0 ; cs < k ; cs++){
cin >> op;
if(op == 1){
cin >> a >> b >> e;
a--, b--;
G[a][b] = min(G[a][b], e);
G[b][a] = min(G[b][a], e);
// Warshall_Floyd();
for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++){
G[i][j] = min(G[i][j], G[i][a] + G[a][b] + G[b][j]);
G[j][i] = G[i][j];
}
}
}
else if(op == 0){
cin >> a >> b;
a--, b--;
if(G[a][b] == INF) cout << -1 << endl;
else cout << G[a][b] << endl;
}
}
}
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#define loop(i,a,b) for(int i=a; i<b; i++)
#define rep(i,a) loop(i,0,a)
using namespace std;
int main(){
int a[5];
while(scanf("%d,%d,%d,%d,%d",&a[0],&a[1],&a[2],&a[3],&a[4])!=EOF){
sort(a,a+5);
int n=0;
rep(i,4)loop(j,i+1,5){
if(a[i]==a[j])n++;
}
bool st=true;
rep(i,4)if(a[i]+1!=a[i+1])st=false;
if(a[0]==1&&
a[1]==10&&
a[2]==11&&
a[3]==12&&
a[4]==13) st=true;
string ans;
if(n==6)
ans="four card";
else if(n==4)
ans="full house";
else if(st)
ans="straight";
else if(n==3)
ans="three card";
else if(n==2)
ans="two pair";
else if(n==1)
ans="one pair";
else
ans="null";
cout<<ans<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define m0(x) memset(x, 0, sizeof(x))
#define all(x) x.begin(), x.end()
#define rep(i, n) for(int i = 0; i < (n); i++)
#define asort(x) sort(all(x));
#define dsort(x, t) sort(x.begin(), x.end(), greater<t>());
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define MINS(m, s) m.insert(make_pair(s, 1));
#define MFIN(m, s) m.find(s) != m.end()
const int mod = 1000000007;
vector<ll> divisor(ll n) {
vector<ll> res;
for(ll i = 1; i * i <= n; i++) {
if(n % i == 0) {
res.push_back(i);
if(i * i != n) {
res.push_back(n / i);
}
}
}
sort(begin(res), end(res));
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
bool isPrime(ll x) {
ll i;
if(x < 2)
return 0;
else if(x == 2)
return 1;
if(x % 2 == 0)
return 0;
for(i = 3; i * i <= x; i += 2)
if(x % i == 0)
return 0;
return 1;
}
int main() {
ll A, B;
cin >> A >> B;
ll ab_gcd = gcd(A, B);
vector<ll> ab_divisor;
ab_divisor = divisor(ab_gcd);
ll cnt = 1;
for(ll i = 0; i < ab_divisor.size(); i++) {
if(isPrime(ab_divisor[i])) {
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0; i<(int)(n); i++)
signed main() {
int a, b;
cin >> a >> b;
int s = 0, n = (int)1e6;
rep(i0,n) {
int i = i0 + 2, fa = 0, fb = 0;
while(a % i == 0) a /= i, fa = 1;
while(b % i == 0) b /= i, fb = 1;
s += (fa && fb);
}
cout << s + 1 + (a != 1 && a == b) << endl;
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <vector>
#include <queue>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <numeric>
#include <iomanip>
// output
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
// utility
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for(int i=(a);i<(n);++i)
#define RFOR(i, a, n) for(int i=(n)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
#define OUT(a, x, b) (x<a || b<=x)
template<class T> inline T chmax(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T chmin(T& a, const T b) { return a = (a > b) ? b : a; }
// type/const
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
/* const int MOD = 998244353; */
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
signed main() {
int N;
cin >> N;
cout << 0 << "\n";
string p;
int pos = 0;
cin >> p;
if(p[0] == 'V'){
cout << 0 << "\n";
return 0;
}
int le = N+1;
int ri = 0;
while(1){
int mid = (ri+le)/2;
cout << mid << "\n";
string s;
cin >> s;
if(s[0] == 'V'){
return 0;
}
if(abs(pos-mid)%2 == 0){
if(s == p) ri = mid;
else le = mid;
}else{
if(s != p) ri = mid;
else le = mid;
}
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
scanf("%d", &n);
int l = 0, r = n;
printf("%d\n", l);
fflush(stdout);
string sl;
cin >> sl;
while (sl != "Vacant") {
int m = (l + r) / 2;
printf("%d\n", m);
fflush(stdout);
string sm;
cin >> sm;
if (sm == "Vacant" || l % 2 == m % 2 && sl == sm || l % 2 != m % 2 && sl != sm) {
l = m;
sl = sm;
} else {
r = m;
}
}
printf("%d\n", l);
fflush(stdout);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
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; }
//(a+b-1)/b
signed main(){
string s; cin>>s;
int n=s.size();
ll ans=0;
ll cnt=0;
rep(i,0,n){
if(s[i]=='S')cnt++;
else if(cnt>0){
cnt--;
ans++;
}
}
cout<<n-(ans*2)<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define MOD 1000000007
void solve()
{
ll x;
cin>>x;
if(x<=6)
cout<<1;
else if(x<=11)
cout<<2;
else if(x%11>6)
cout<<(x/11)*2+2;
else if(x%11==0)
cout<<(x/11)*2;
else
cout<<(x/11)*2+1;
return;
}
int main()
{
fast;
ll q=1;
// cin>>q;
while(q--)
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < ll(n); i++)
int main() {
int n;
cin >> n;
n -= 2;
cout << n * 180 << endl;
} | #include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) printf("%lld ",i);puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
int main(){
int n=read();
printf("%d\n",(n-2)*180);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
template< typename T >
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename G >
struct LowLink {
const G &g;
vector< int > used, ord, low;
vector< int > articulation;
vector< pair< int, int > > bridge;
LowLink(const G &g) : g(g), used(g.size()), ord(g.size()), low(g.size()) {}
int build(int idx = 0, int k = 0, int par = -1) {
used[idx] = true;
ord[idx] = k++;
low[idx] = ord[idx];
bool is_articulation = false;
int cnt = 0, ordmax = k;
for(auto &to : g[idx]) {
if(!used[to]) {
++cnt;
ordmax = build(to, ordmax, idx);
low[idx] = min(low[idx], low[to]);
is_articulation |= ~par && low[to] >= ord[idx];
if(ord[idx] < low[to]) bridge.emplace_back(idx, to);
} else if(to != par) {
low[idx] = min(low[idx], ord[to]);
}
}
is_articulation |= par == -1 && cnt > 1;
if(is_articulation) articulation.push_back(idx);
return ordmax;
}
};
int main() {
int V, E;
scanf("%d %d", &V, &E);
UnWeightedGraph g(V);
for(int i = 0; i < E; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
LowLink< UnWeightedGraph > lowlink(g);
lowlink.build();
sort(lowlink.articulation.begin(), lowlink.articulation.end());
for(auto &v : lowlink.articulation) printf("%d\n", v);
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int H, W;
cin >> H >> W;
vector<vector<int>> a(H, vector<int>(W));
for (int i = 0; i < H; i++){
for (int j = 0; j < W; j++){
cin >> a[i][j];
}
}
vector<tuple<int, int, int, int>> op;
for (int i = 0; i < H; i++){
for (int j = 0; j < W - 1; j++){
if (a[i][j] % 2 == 1){
a[i][j]--;
a[i][j + 1]++;
op.push_back(make_tuple(i + 1, j + 1, i + 1, j + 2));
}
}
}
for (int i = 0; i < H - 1; i++){
if (a[i][W - 1] % 2 == 1){
a[i][W - 1]--;
a[i + 1][W - 1]++;
op.push_back(make_tuple(i + 1, W, i + 2, W));
}
}
int N = op.size();
cout << N << endl;
for (int i = 0; i < N; i++){
cout << get<0>(op[i]) << ' ' << get<1>(op[i]) << ' ' << get<2>(op[i]) << ' ' << get<3>(op[i]) << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define gcd std::__gcd
#define EB emplace_back
typedef std::vector <int> vector;
const int N = 100054;
int n;
vector a;
inline bool judge(const vector &v) {
int c[2] = {0}, g = 0; bool one = false; vector u(v);
for (int x : v) ++c[x & 1], one |= x == 1;
if (*c & 1) return true;
if (one || c[1] > 1) return false;
for (int &x : u) g = gcd(g, x &= -2);
for (int &x : u) x /= g;
return !judge(u);
}
int main() {
int i, x;
scanf("%d", &n), a.reserve(n);
for (i = 1; i <= n; ++i) scanf("%d", &x), a.EB(x);
return puts(judge(a) ? "First" : "Second"), 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
const int N=1e5+10;
int n,a[N];
void Put(int p) {p&1?puts("First"):puts("Second");exit(0);}
void dfs(int p)
{
int od=0,ov=0,g=0,mn=1e9;
for(int i=1;i<=n;i++) a[i]&1?od++:ov++,mn=min(mn,a[i]);
if(ov&1) Put(p);
if(od>1||mn==1) Put(p^1);
for(int i=1;i<=n;g=__gcd(g,a[i]),i++) if(a[i]&1) a[i]--;
for(int i=1;i<=n;i++) a[i]/=g;
dfs(p^1);
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
if(n==1) Put(a[1]-1);dfs(1);
}
| 1 |
#include <bits/stdc++.h>
#define ALL(A) (A).begin(), (A).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); i++)
const ll MOD = 1e9 + 7;
const ll INF = -1 * ((1LL << 63) + 1);
const int inf = -1 * ((1 << 31) + 1);
using namespace std;
int N, M;
vector<int> A, B;
long long solve()
{
ll res = 1;
int biggerX_a = 0, biggerX_b = 0; // A,B でxより大きい数値の個数
for (int x = N * M; x >= 1; x--)
{
/*if (A[biggerX_a] > x)
return 0;
if (B[biggerX_b] > x)
return 0;
*/
long long tmp = 1;
if (A[biggerX_a] == x && B[biggerX_b] == x)
{
tmp = 1;
++biggerX_a, ++biggerX_b;
}
else if (A[biggerX_a] == x)
{
tmp = biggerX_b;
++biggerX_a;
}
else if (B[biggerX_b] == x)
{
tmp = biggerX_a;
++biggerX_b;
}
else
{
tmp = biggerX_a * biggerX_b - (N * M - x);
if (tmp <= 0)
return 0;
}
res = (res * tmp) % MOD;
}
return res;
}
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
A.resize(N+1);
B.resize(M+1);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i];
sort(ALL(A), greater<int>());
sort(ALL(B), greater<int>());
cout << solve() << endl;
} | #include <bits/stdc++.h>
using namespace std;
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<ld> vld;
typedef vector<pll> vpl;
typedef vector<vll> vvll;
#define ALL(a) a.begin(),a.end()
#define SZ(a) ((int)a.size())
#define FI first
#define SE second
#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 FOR(i,a,b) for(int i=(a);i<(b);i++)
#define PB push_back
#define EB emplace_back
#define MP(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define yes cout<<"Yes"<<endl
#define YES cout<<"YES"<<endl
#define no cout<<"No"<<endl
#define NO cout<<"NO"<<endl
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
const int inf = 1e9;
const ll linf = 1LL << 50;
const double eps = 1e-10;
const int MOD = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,m;
cin>>n>>m;
vvll a(n,vll(m));
REP(i,n)REP(j,m)cin>>a[i][j];
vector<queue<ll>> b(n);
REP(i,n){
REP(j,m){
a[i][j]--;
b[i].push(a[i][j]);
}
}
ll ans=LLINF;
vll removed(m);
REP(i,m){
vpl picked(m);
REP(j,m)picked[j].SE=j;
REP(j,n){
ll t=b[j].front();
picked[t].FI++;
}
sort(ALL(picked), greater<pll>());
ll now=picked[0].FI;
ll max_a=picked[0].SE;
ans=min(ans,now);
//remove most picked
removed[max_a]=1;
REP(j,n){
while(!b[j].empty()){
ll t=b[j].front();
if(removed[t])
b[j].pop();
else
break;
}
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
int count = 0;
int score = 0;
cin >> N;
vector<string> s(N);
for(int i=0;i<N;i++){
cin >> s.at(i);
}
cin >> M;
vector<string> t(M);
for(int i=0;i<M;i++){
cin >> t.at(i);
}
for(int i=0;i<N;i++){
count = 0;
for(int j=0;j<N;j++){
if(s.at(i) == s.at(j)) count++;
}
for(int j=0;j<M;j++){
if(s.at(i) == t.at(j)) count--;
}
score = max(score,count);
}
cout << score << endl;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int N;
long x;
cin >> N >> x;
vector<long> a(N);
for (int i=0; i<N; i++) {
cin >> a.at(i);
}
sort(a.begin(), a.end());
int cnt=0;
for (int i=0; i<N; i++) {
cnt++;
x -= a.at(i);
if (x<=0) {
break;
}
}
if (x!=0) cnt--;
cout << cnt << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
//class
class Baseball{
public:
int firstbase, secondbase, thirdbase;
int inningNumber, out, score;
Baseball(int num){
inningNumber = num;
firstbase = 0;
secondbase = 0;
thirdbase = 0;
out = 0;
score = 0;
}
void playball(){
for(int i = 0; i < inningNumber; ++i)
inning();
}
void inning(){
out = 0;
firstbase = 0;
secondbase = 0;
thirdbase = 0;
score = 0;
while(out != 3){
std::string str;
std::cin >> str;
if(str == "HIT")
hit();
if(str == "HOMERUN")
homerun();
if(str == "OUT")
out++;
}
std::cout << score << std::endl;
}
void hit(){
score += thirdbase;
thirdbase = secondbase;
secondbase = firstbase;
firstbase = 1;
}
void homerun(){
score += thirdbase + secondbase + firstbase + 1;
firstbase = 0;
secondbase = 0;
thirdbase = 0;
}
};
//main
int main(){
int n;
std::cin >> n;
Baseball *baseball = new Baseball(n);
baseball->playball();
delete baseball;
return 0;
}
| #include <iostream>
using namespace std;
int main(){
int m,d;
while(cin>>m>>d){
if(!m) break;
int daym[12]={0,31,60,91,121,152,182,213,244,274,305,335};
int wd = (daym[m-1] + d + 2)%7;
switch(wd){
case 0:
cout <<"Monday"<<endl;
break;
case 1:
cout<<"Tuesday"<<endl;
break;
case 2:
cout<<"Wednesday"<<endl;
break;
case 3:
cout<<"Thursday"<<endl;
break;
case 4:
cout<<"Friday"<<endl;
break;
case 5:
cout<<"Saturday"<<endl;
break;
case 6:
cout<<"Sunday"<<endl;
break;
}
}
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int n,m;
while(cin>>n>>m&&n)
{
vector<int> a;
int ans=0;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
a.push_back(x);
}
sort(a.begin(),a.end());
for(int i=0;i<n%m;i++)
{
ans+=a[0];;
a.erase(a.begin());
}
n-=n%m;
for(int i=0;i<a.size();i++)ans+=a[i];
for(int i=0;i<n/m;i++)
{
ans-=a[i*m];
}
cout<<ans<<endl;
}
} | //
// main.cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int n,k,cards[11];
bool selected[11];
vector<vector<int>> selectlist;
vector<int> makelist;
void reset(){
n = k = 0;
selectlist.clear();
makelist.clear();
for(int i=0;i<11;i++){
cards[i] = 0;
selected[i] = false;
}
}
void select_dfs_(int depth,int top,vector<int> vec){
if(depth == k){
selectlist.push_back(vec);
return;
}
for(int i=top+1;i<n;i++){
vec.push_back(cards[i]);
select_dfs_(depth+1,i,vec);
vec.pop_back();
}
}
void makeint_dfs_(int depth,int makedint,vector<int> source){
if(depth == k){
makelist.push_back(makedint);
return;
}
for(int i=0;i<k;i++){
if(!selected[i]){
selected[i] = true;
int maked;
if(source[i]/10 > 0){
maked = makedint*100+source[i];
}else{
maked = makedint*10+source[i];
}
makeint_dfs_(depth+1,maked,source);
selected[i] = false;
}
}
}
int main(){
while(1){
reset();
cin >> n >> k;
if(n == 0 && k == 0)break;
for(int i=0;i<n;i++){
cin >> cards[i];
}
for(int i=0;i<n-k+1;i++){
vector<int> vec;
vec.push_back(cards[i]);
select_dfs_(1,i,vec);
}
for(int i=0;i<selectlist.size();i++){
for(int j=0;j<selectlist[i].size();j++){
selected[j] = true;
makeint_dfs_(1,selectlist[i][j],selectlist[i]);
selected[j] = false;
}
}
sort(makelist.begin(),makelist.end());
int answer=0,memo=-1;
for(int i=0;i<makelist.size();i++){
if(memo != makelist[i]){
answer ++;
memo = makelist[i];
}
}
cout << answer << endl;
}
return 0;
} | 0 |
//http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP1_5_D
#include <iostream>
using namespace std;
bool div(int n){
if(n % 3 == 0) return true;
else return false;
}
bool isIn3(int n){
if((n-3) % 10 == 0) return true;
else return false;
}
bool in3(int n){
while(n > 10){
n /= 10;
if(isIn3(n)) return true;
}
return false;
}
int main(){
int n;
cin >> n;
for(int i=1; i <= n; i++){
if(div(i) || isIn3(i)|| in3(i)) cout << " " << i;
}
cout << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define pb(s) push_back(s)
#define ALL(v) v.begin(), v.end()
#define ALLA(arr, sz) arr, arr + sz
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define SORTA(arr, sz) sort(ALLA(arr, sz))
#define REVERSEA(arr, sz) reverse(ALLA(arr, sz))
#define PI 3.14159265358979323846264338327950L
typedef long long ll;
const ll MOD =1e9+7;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
ll x;
cin>>x;
ll ans=0;
ans+=2*(x/11);
x%=11;
if(x>0)ans++;
if(x>6)ans++;
cout<<ans;
return 0;
}
| 0 |
#include<iostream>
#include<vector>
using namespace std;
long long N,ans;
string S;
string S1,S2;
vector <string> V1,V2;
string convstr(string str,long long key){
string f="";string l="";
for (long long i=0;i<N;i++){
if ((key&(1<<i))!=0){
f=f+str[i];
} else l=str[i]+l;
}
return f+" "+l;
}
int main(){
cin >> N >> S;
S1="";S2="";
for (long long i=0;i<N;i++){
S1=S1+S[i];
S2=S2+S[2*N-1-i];
}
for (long long i=0;i<(1<<N);i++){
V1.push_back(convstr(S1,i));
}
sort(&V1[0],&V1[1<<N]);
/*
for (int i=0;i<V1.size();i++){
cout << V1[i] << endl;
}
*/
for (long long i=0;i<(1<<N);i++){
V2.push_back(convstr(S2,i));
}
sort(&V2[0],&V2[1<<N]);
/*
for (int i=0;i<V2.size();i++){
cout << V2[i] << endl;
}
*/
long long idx1=0,idx2=0;
long long mul1=0,mul2=0;
ans=0;
while(idx1<(1<<N) && idx2<(1<<N)){
if (V1[idx1]>V2[idx2]){
idx2++;continue;
}
if (V1[idx1]<V2[idx2]){
idx1++;continue;
}
mul1=0;mul2=0;
while(idx1+mul1<(1<<N) && V1[idx1]==V1[idx1+mul1]){
mul1++;
}
while(idx2+mul2<(1<<N) && V2[idx2]==V2[idx2+mul2]){
mul2++;
}
ans+=mul1*mul2;
//cout << V1[idx1] << " " << V2[idx2]<<" " << mul1*mul2 <<endl;
idx1+=mul1;idx2+=mul2;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
string s;
int memo[310][310][310];
int dp(int l, int r, int k){
if(l > r){
return 0;
}
if(l == r){
return 1;
}
if(memo[l][r][k] != -1) return memo[l][r][k];
int ans = 0;
ans = max(ans, dp(l+1, r, k));
ans = max(ans, dp(l, r-1, k));
if(s[l] == s[r]){
ans = max(ans, dp(l+1, r-1, k)+2);
}else if(k > 0){
ans = max(ans, dp(l+1, r-1, k-1)+2);
}
return memo[l][r][k] = ans;
}
int main(){
cin >> s;
int k;
cin >> k;
memset(memo, -1, sizeof(memo));
cout << dp(0, s.size()-1, k) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
typedef long long ll;
const int N=5005,P=998244353;
int n,k,C[N][N];
inline int Cs(int n,int m){return n<0||m<0||n<m?0:C[n][m];}
int main()
{
scanf("%d%d",&k,&n);
for(int i=C[0][0]=1;i<=5001;++i)
for(int j=C[i][0]=1;j<=i;++j)
if((C[i][j]=C[i-1][j]+C[i-1][j-1])>=P)
C[i][j]-=P;
for(int i=2,j,u,v,s;i<=k<<1;printf("%d\n",s),++i)
for(u=std::min(k,i>>1),v=std::max(1,i-k),s=j=0;j<=u-v+1;++j)
s=(s+(ll)Cs(u-v+1,j)*Cs(n+k-j-j-1,n-j-j)%P*(j&1?P-1:1))%P;
return 0;
}
| #include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int N, K;
const ll MOD = 998244353;
ll F[4002], F_inv[4002];
ll modpow(ll a, ll b) {
ll rtn = 1, kakeru = a;
while (b > 0) {
if (b & 1)rtn *= kakeru;
kakeru *= kakeru;
kakeru %= MOD;
rtn %= MOD;
b >>= 1;
}
return rtn;
}
void calc_fac() {
F[0] = 1, F[1] = 1;
for (int i = 2; i <= 4001; i++) {
F[i] = F[i - 1] * i;
F[i] %= MOD;
}
F_inv[4001] = modpow(F[4001], MOD - 2);
for (int j = 4000; j >= 0; j--) {
F_inv[j] = F_inv[j + 1] * (j + 1);
F_inv[j] %= MOD;
}
}
ll comb(ll a, ll b) {
if (a < 0)return 0;
if (b < 0)return 0;
if (b > a)return 0;
ll ans = (F[a] * F_inv[b])%MOD * F_inv[a - b];
return ans % MOD;
}
ll hcomb(ll a, ll b) {
return comb(a + b - 1, b);
}
int main() {
calc_fac();
cin >> K >> N;
for (int i = 2; i <= 2 * K; i++) {
if (i % 2 == 1) {
ll cnt = 0;
int A = min((i - 1) / 2, (2 * (K + 1) - i) / 2);
for (int j = 0; j <= A; j++) {
ll tmp = 1;
tmp *= (modpow(2, j) * comb(A, j)) % MOD;
tmp *= hcomb(K - 2 * A + j, N - j);
tmp %= MOD;
cnt += tmp;
cnt %= MOD;
}
cout << cnt << endl;
}
else {
ll cnt = 0;
int A = min((i) / 2, (2 * (K + 1) - i) / 2) - 1;
for (int j = 0; j <= A; j++) {
ll tmp = 1;
tmp *= (modpow(2, j) * comb(A, j)) % MOD;
ll a = hcomb(K - 2 * A + j - 1, N - j) + hcomb(K - 2 * A + j - 1, N - j - 1);
a %= MOD;
tmp *= a;
tmp %= MOD;
cnt += tmp;
cnt %= MOD;
}
cout << cnt << endl;
}
}
return 0;
} | 1 |
#include <iostream>
#include <cstring>
using namespace std;
int main(){
int md[11] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30};
int m, d;
string str[7] = {"Wednesday", "Thursday", "Friday", "Saturday", "Sunday", "Monday", "Tuesday"};
while(true){
cin >> m >> d;
if(m == 0 && d == 0) return 0;
for(int i = 1; i < m; i++){
d += md[i - 1];
}
cout << str[d % 7] << endl;
}
} | #include<iostream>
#include<cstdio>
using namespace std;
int main(){
int l[10],v1,v2;
int result,ans;
double total, time, distance;
while(scanf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",&l[0],&l[1],&l[2],&l[3],&l[4],&l[5],&l[6],&l[7],&l[8],&l[9],&v1,&v2) != EOF){
total=0;
for(int i=0; i<10; i++)
total += l[i];
time = (double)total/(v1+v2);
distance = v1 * time;
result = 0;
for(ans=0; result < distance; ans++)
result += l[ans];
cout << ans << endl;
}
} | 0 |
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<iomanip>
#include<cmath>
#define REP(i,n) for (int i = 0; (i) < (n); ++ (i))
#define FOR(i,n) for (int i = 1; (i) <= (n); ++ (i))
#define dump(x) cout << #x << " = " << (x) << endl;
#define pb push_back
#define int long long
const int INF = 1e18;
const int MOD = 1e9+7;
//const lint LINF = 1e18;
const double eps = 0.000000001;//もとの値の10^(-16)まで
using namespace std;
//typedef pair<int, int> P;
//priority_queue< P, vector<P>, greater<P> > q;//ダイクストラの時、greaterで小さい順
//cout << fixed << setprecision(10) << ans << endl;
//int gcd(int a,int b){return b?gcd(b,a%b):a;}
int a[200000];
int b[200000];
signed main(){
int n,m,v,p;
cin >> n >> m >> v >> p;
REP(i,n){
cin >> a[i];
}
sort(a,a+n);
reverse(a,a+n);
int left = 0;
int right = n;
while(right - left >= 2){
int v2 = v;
int mid = (left+right)/2;
if(mid < p){
left = mid;
continue;
}
v2 -= p-1;
v2 -= n-mid;
if(v2 <= 0 && a[mid] + m-a[p-1]>=0){
left = mid;
continue;
}
else if(v2 <= 0 && a[mid] + m-a[p-1]<0){
right = mid;
continue;
}
int nokori = 0;
int f = 0;
for(int i = p-1;i<=mid-1;i++){
int now = a[mid] + m - a[i];
if(now < 0) f=1;
nokori += min(now,m);
}
if(f==1){
right = mid;
continue;
}
if(nokori >= m*v2){
left = mid;
continue;
}
else{
right = mid;
continue;
}
}
cout << right << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}
ll nextLong() { ll x; scanf("%lld", &x); return x;}
ll rev(ll n) {
ll res = 0;
while (n > 0) {
int r = n % 10;
res = res * 10 + r;
n /= 10;
}
return res;
}
bool check(ll N, ll D) {
return rev(N) == N + D;
}
ll ways0(int m) {
if (m < 0) return 0;
return 9-m;
}
ll ways(int m) {
return 10-abs(m);
}
ll ten[20];
ll total = 0;
void rec(ll L, ll R, ll D, ll curr) {
if (curr == 0) return;
if (L == R) {
if (D == 0) {
total += curr * 10;
}
return;
}
if (L < R) {
if (D == 0) {
total += curr;
}
return;
}
ll C = ten[L] - ten[R];
if (D < -C*10 || C*10 < D) return;
if (R == 0) {
for (int a = 0; a <= 9; a++) {
rec(L-1, R+1, D - (ten[L]-ten[R]) * a, curr * ways0(a));
}
} else {
for (int a = -9; a <= 9; a++) {
rec(L-1, R+1, D - (ten[L]-ten[R]) * a, curr * ways(a));
}
}
}
ll solve(ll D, ll k) {
if (k <= 6) {
ll res = 0;
for (int n = ten[k-1]; n < ten[k]; n++) {
if (check(n, D)) ++res;
}
return res;
}
total = 0;
rec(k-1, 0, D, 1);
return total;
}
int main2() {
ll D = nextLong();
ll ans = 0;
for (int k = 1; k <= 18; k++) {
ans += solve(D, k);
}
cout << ans << endl;
return 0;
}
int main() {
ten[0] = 1;
for (int i = 1; i < 20; i++) ten[i] = ten[i-1] * 10;
#ifdef LOCAL
for (;!cin.eof();cin>>ws)
#endif
main2();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-8;
long double a = 25.0;
long double b = 26.0;
long double c = 1.0;
long long seek(long long Ntemp){
long double X = a*( (long double) Ntemp ) + b ;
return (long long) ceil( log10(X)/log10(b) - c );
}
int main(){
long long N;
cin >> N;
string S;
long long n = seek(N);
N = N - ( (long long) ( pow(b, ((long double) n) ) - b + eps ) /a );
//cout << "N n " << N << " " << n << endl;
// # S is n characters
long long ntemp = n;
for(int i=0; i<n; i++){
ntemp = ntemp - 1;
long long A = (long long) ( pow( b, (long double) (ntemp) ) + eps );
int ctmp = (int) ( (N-1)/A );
char ctmp2 = 'a' + ctmp;
S.push_back(ctmp2);
//cout << "i ntemp A ctmp N S " << i << " " << ntemp << " " << A << " " << ctmp << " " << N << " " << S << endl;
N = N - ( (long long) ctmp )*A;
}
cout << S << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll n;
int main(){
cin >> n;
string ans = "";
while(n>0){
n--;
ans = char((n)%26+'a')+ans;
n/=26;
}
cout << ans << endl;
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int n, m, i, point[1000] = { 0 }, kyougi[1000] = { 0 }, ans = 0, tmp = 0, j;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> kyougi[i];
}
for (i = 0; i < m; i++) {
int sinsa;
cin >> sinsa;
for (j = 0; j < n; j++) {
if (kyougi[j] <= sinsa) {
point[j]++;
break;
}
}
}
for (i = 0; i < m; i++) {
if (tmp < point[i]) {
tmp = point[i];
ans = i;
}
}
cout << ans+1 << endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
while(true){
int n,m;
cin >> n ;
if(cin.eof()) break;
cin >> m;
vector<int> a(1000);
vector<int> b(1000);
vector<int> c(1000);
vector<bool> u(1000);
vector<int> ans(1000);
fill(u.begin(),u.end(),true);
for(int i=0;i<n;i++){
cin >> a[i];
};
for(int i=0;i<m;i++){
cin >> b[i];
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(u[j] && a[i] <= b[j]){
u[j] = false;
ans[i]++;
}
}
}
int res = -1,ansnum = 0;;
for(int i=0;i<n;i++){
if(res < ans[i]){
res = ans[i];
ansnum = i + 1;
}
}
cout << ansnum << endl;
}
return 0;
} | 1 |
/*
Contest 091
B - Two Colors Card Game
Rakesh Kumar --> 21/09/2020
*/
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0); std::cout.tie(0);
std::unordered_map<std::string, int> dict;
int n = 0;
std::cin >> n;
std::cin.ignore();
while (n--) {
std::string s;
std::getline(std::cin, s);
++dict[s];
}
std::cin >> n;
std::cin.ignore();
while (n--) {
std::string s;
std::getline(std::cin, s);
--dict[s];
}
int max = 0;
for (auto it : dict)
max = std::max(max, it.second);
std::cout << max << std::endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
#include <cmath>
#include <map>
#include <iomanip>
using ll = long long;
using ld = long double;
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
int const nmax = 200000;
std::vector<std::pair<int,int>> v;
std::map<std::pair<int,int>,int> mp;
int main() {
int n;
std::cin >> n;
for(int i = 1;i <= n; i++) {
ld init;
std::cin >> init;
ll number = llround(1000000000LL * init);
std::pair<int,int> basic(0, 0);
while(number % 2 == 0) {
number /= 2;
basic.first++;
}
while(number % 5 == 0) {
number /= 5;
basic.second++;
}
mp[basic]++;
if(mp[basic] == 1)
v.push_back(basic);
}
ll result = 0;
for(int i = 0; i < v.size(); i++)
for(int j = i; j < v.size(); j++)
if(18 <= v[i].first + v[j].first && 18 <= v[i].second + v[j].second) {
if(i == j)
result += 1LL * mp[v[i]] * (mp[v[i]] - 1) / 2;
else
result += 1LL * mp[v[i]] * mp[v[j]];
}
std::cout << result;
}
| 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;
vi a(n+1),b(n+1,0),ans;
rep(i,n)cin >> a[i+1];
for(int i = n;i>=1;i--){
int sum = 0;
for(int j = i;j<=n;j+=i){
sum+=b[j];
}
if(sum%2 != a[i]){
b[i] = 1;
ans.push_back(i);
}
}
cout<<sz(ans)<<endl;
rep(i,sz(ans))cout<<ans[i]<<" ";
cout<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define X ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FIXED_FLOAT(x) std::fixed <<std::setprecision(2)<<(x)
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
// long long p = 1e9+7;
typedef long long ll;
typedef pair<ll,ll> pl;
typedef vector<int> VI;
typedef vector<pair<ll,ll>> VP;
typedef vector<ll> VL;
typedef vector<bool> VB;
// typedef pair<ll, ll> PL;
typedef unordered_map<ll, ll> UMP;
#define FOR(i,b) for(i=0;i<b;i++)
#define pb push_back
#define mp make_pair
// typedef unordered_set<ll>;
void printa(VI &x,ll n){
ll i;
FOR(i, n){
cout<<x[i]<<" ";
}
cout<<endl;
}
/////GLOABLS VARS
ll MOD = 1e9+7;
ll gmx = 1e6+7;
VL fact(gmx, 1);
//////FUNCTIONS
ll powp(ll val, ll deg)
{
// debug(val, deg);
if (!deg)
return 1;
if (deg & 1)
return (powp(val, deg - 1) * val) % MOD;
ll res = powp(val, deg >> 1);
// debug(res);
return (res * res) % MOD;
}
//It is not easy but it can be fun, if you think!!!
//
// ll mx = 2*1e5+7;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
// #endif
ll n,i,j;
cin>>n;
// priority_queue<ll> l;
VL l(n+1);
FOR(i,n){
ll u;
cin>>u;
l[i+1] = u;
}
VL arr(n+1);
ll m = sqrt(n)+1;
VL ans;
for(i=n;i>=1;i--){
// debug(arr,l);
if(l[i]!=arr[i]){
// debug(i);
ans.pb(i);
unordered_set<ll> seen;
for(j = 1;j<m;j++){
if(i%j==0){
ll p =i/j;
// debug(p,j);
if(p==j){
if(seen.find(p)==seen.end()){
arr[p] =1-arr[p];
seen.insert(p);
}
// ans.pb(p);
}
else{
if(seen.find(p)==seen.end()){
arr[p] =1-arr[p];seen.insert(p);
}
if(seen.find(j)==seen.end()){
arr[j] =1-arr[j];seen.insert(j);
}
// ans.pb(p);
// ans.pb(j);
}
}
}
}
}
cout<<ans.size()<<'\n';
for(auto k:ans){
cout<<k<<'\n';
}
// }
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int n,m,v,p,u,ans;
long long g,a[200005],sy,d,s[200005];
int main()
{
scanf("%d%d%d%d",&n,&m,&v,&p);
for (int i=1;i<=n;i++)
scanf("%lld",&a[i]);
sort(a+1,a+n+1);
g=a[n-p+1];
for (int i=1;i<=n;i++)
s[i]=s[i-1]+a[i];
ans=p;
for (int i=1;i<=n-p;i++)
{
if (g>a[i]+m)
continue;
sy=(long long)m*(long long)(v-1);
d=(long long)m*(long long)(n-1);
d-=s[n-p+1]-s[i-1]-(long long)(n-p-i+2)*a[i];
if (sy<=d)
ans++;
}
printf("%d\n",ans);
return 0;
} | ///Bismillahir Rahmanir Rahim
#include<bits/stdc++.h>
#define int long long
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<int,int>
#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 fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int inf=1e18;
const int mod=1e9+7;
const int M=100009;
inline int bigmod(int B,int P){int R=1;while(P>0){if(P&1){R=(R*B)%mod;}P>>=1;B=(B*B)%mod;}return R;}
inline int ad(int x,int y){int ret=(x%mod+y%mod)%mod;if(ret<0){ret+=mod,ret=ret%mod;}return ret;}
inline int sub(int x,int y){int ret=((x%mod)-(y%mod)+mod)%mod;if(ret<0){ret+=mod,ret=ret%mod;}return ret;}
inline int gun(int x,int y){int ret=((x%mod)*(y%mod))%mod;if(ret<0){ret+=mod,ret=ret%mod;}return ret;}
int n,m,v,p;
vector<pi>vec;
int a[M+3];
bool vis[M+3];
bool chk(int idx)
{
int big=p-1;
int use=v-1;
int mn=min(big,use);
big-=mn;
use-=mn;
vector<pi>yo;
if(vis[idx])return true;
int mx=vec[idx].fi+m;
int sum=use*m;
//cout<<sum<<" ### "<<endl;
for(int i=p-1;i<n;i++)
{
if(i==idx)continue;
int val=vec[i].fi;
int gap=mx-val;
if(gap<0)
{
//cout<<i<<" "<<mx<<" "<<val<<endl;
}
if(gap<0)return false;
int can=min(gap,m);
sum-=can;
}
if(sum<=0)return true;
else return false;
}
main()
{
fast
cin>>n>>m>>v>>p;
f(i,1,n)
{
int x;
cin>>x;
a[i]=x;
vec.pb(mp(x,i));
}
sort(vec.rbegin(),vec.rend());
int last;
for(int i=0;i<p;i++)
{
vis[i]=true;
last=vec[i].fi;
}
for(int i=p;i<n;i++)
{
if(vec[i].fi==last)
{
vis[i]=true;
}
else break;
}
// cout<<chk(3)<<"#"<<endl;
int lo=0,hi=n-1;
while(hi-lo>=2)
{
int mid=(lo+hi)>>1;
if(chk(mid))lo=mid;
else hi=mid-1;
}
int ses=-1;
for(int i=lo;i<=hi;i++)
{
if(chk(i))ses=i;
}
if(ses==-1)
{
cout<<"0"<<endl;
return 0;
}
ses=ses+1;
cout<<ses<<endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
int dfs(auto& nodes, int current_index, int parent_index, int& time) {
int children = 0;
auto& current_node = nodes[current_index];
current_node.time = time;
current_node.low = time;
for (auto adjacent_index : current_node.adjacent) {
if (adjacent_index == parent_index) {
continue;
}
auto& adjacent_node = nodes[adjacent_index];
if (adjacent_node.time) {
current_node.low = min(adjacent_node.time, current_node.low);
} else {
++children;
dfs(nodes, adjacent_index, current_index, ++time);
if (current_node.time <= adjacent_node.low) {
current_node.is_articulation_point = true;
}
current_node.low = min(adjacent_node.low, current_node.low);
}
}
return children;
}
int main() {
int n, m;
cin >> n >> m;
if (n == 0 || m == 0) {
return 0;
}
struct node {
int time{0};
int low{0};
bool is_articulation_point{false};
vector<int> adjacent;
};
vector<node> nodes(n);
for (int i = 0; i < m; ++i) {
int from, to;
cin >> from >> to;
nodes[from].adjacent.push_back(to);
nodes[to].adjacent.push_back(from);
}
int time = 0;
nodes[0].is_articulation_point = dfs(nodes, 0, -1, ++time) > 1;
for (int i = 0; i < nodes.size(); ++i) {
if (nodes[i].is_articulation_point) {
cout << i << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
#define all(x) x.begin(), x.end()
#define rep(i,a,b) for(int i = a; i < b; i++)
int V, E;
vvi conn(100002);
vi vis(100002);
vb trail(100002);
vb cut(100002);
int dfs_min(int v, int depth, int parent) {
if(vis[v] > 0) return vis[v];
vis[v] = depth;
trail[v] = true;
int minHit = depth;
rep(i,0,(int)conn[v].size()) {
if(conn[v][i] != parent && (vis[conn[v][i]] == 0 || trail[conn[v][i]])) {
int hit = dfs_min(conn[v][i], depth+1, v);
minHit = min(minHit, hit);
if(hit >= depth && conn[v].size() > 1)
cut[v] = true;
}
}
trail[v] = false;
return minHit;
}
int main() {
cin >> V;
cin >> E;
rep(e,0,E) {
int s, t;
cin >> s;
cin >> t;
conn[s].push_back(t);
conn[t].push_back(s);
}
dfs_min(0, 1, -1);
if(V > 1) {
cut[0] = false;
bool remember = cut[1];
fill(all(vis), 0);
dfs_min(1, 1, -1);
cut[1] = remember;
}
rep(v,0,V)
if(cut[v])
cout << v << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[100005],b[100005];
int q[100005];
int main() {
int n,s;
scanf("%d%d",&n,&s);
int id=0;
for(int i=1;i<=n;i++) {
scanf("%lld%lld",&a[i],&b[i]);
if (a[i]<s) id=i;
}
int cnt=0,l=1,r=n;
while ((l<=id)^(r<=id))
if (b[l]>=b[r]) {
q[++cnt]=a[r];
b[l]+=b[r];
r--;
}
else {
q[++cnt]=a[l];
b[r]+=b[l];
l++;
}
if (r<=id) {
for(int i=l;i<=r;i++) q[++cnt]=a[i];
}
else {
for(int i=r;i>=l;i--) q[++cnt]=a[i];
}
q[cnt+1]=s;
ll ans=0;
for(int i=1;i<=cnt;i++) ans+=abs(q[i]-q[i+1]);
printf("%lld\n",ans);
return 0;
} | #include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int iINF = 1000000000;
const long long int llINF = 1000000000000000000;
const double PI = acos(-1.0);
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long int;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using edge = struct
{
int to;
int cost;
};
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vector<edge> graph;
class UnionFind
{
private:
vector<int> par;
vector<int> sizes;
public:
UnionFind(int N) : par(N), sizes(N, 1)
{
rep(i, N) par[i] = i;
}
int find(int x)
{
if (x == par[x])
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y)
{
x = find(x);
y = find(y);
if (x == y)
return;
if (sizes[x] < sizes[y])
swap(x, y);
par[y] = x;
sizes[x] += sizes[y];
}
bool same(int x, int y)
{
return find(x) == find(y);
}
int size(int x)
{
return sizes[find(x)];
}
};
int main()
{
int V, E;
cin >> V >> E;
vector<tuple<int, int, int>> graph; //cost, from, to
rep(i, E)
{
int s, t, w;
cin >> s >> t >> w;
graph.push_back(T{w, s, t});
graph.push_back(T{w, t, s});
}
sort(graph.begin(), graph.end());
UnionFind uf(V);
ll ans = 0;
for(auto e : graph)
{
int from, to, cost;
tie(cost, from, to) = e;
if(!uf.same(from, to))
{
ans += cost;
uf.unite(from, to);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
#define rep(i, f, n) for (ll i = (f); i < (ll)(n); i++)
#define repe(i, f, n) for (ll i = (f); i <= (ll)(n); i++)
#define accum(x) accumulate((x).begin(), (x).end(), 0)
using namespace std;
using ll = long long;
using pint = pair<int, int>;
const ll MOD = 1e9 + 7;
int a[1001];
void f(int X) {
int x = X;
for (int i = 2; i * i <= X; i++) {
if (x % i != 0) continue;
while (x % i == 0) {
a[i]++;
x /= i;
}
}
if (x != 1) a[x]++;
}
int main() {
int n;
cin >> n;
repe(i, 2, n) f(i);
ll ans = 1;
repe(i, 2, n) {
if (a[i] == 0) continue;
ans *= a[i] + 1;
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
#define rep(i,N) for(int i=0;i<(N);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e12;
const int inf = 1e9;
typedef long long ll;
typedef pair<ll,int> P;
typedef set<int> S;
int main(){
int n;
cin>>n;
int cnt = 0;
if(n<3){
cout<<0<<endl;
return 0;
}
cnt = 0;
while(n>=3){
cnt++;
n-=3;
}
cout<<cnt<<endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <string>
#include <map>
#include <functional>
#include <cmath>
#include <cstdio>
using namespace std;
#define PI 4*atan(1);
int main(){
int n, a, b, c;
vector<int> ans;
ans.push_back(1);
cin >> n;
if(n == 2){
cin >> a >> b;
for(int i = 2; i < max(a, b); i++){
if(a % i == 0 && b % i == 0){
ans.push_back(i);
}
}
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << endl;
}
}else if(n == 3){
cin >> a >> b >> c;
for(int i = 2; i < max(max(a, b), c); i++){
if(a % i == 0 && b % i == 0 && c % i == 0){
ans.push_back(i);
}
}
for(int i = 0; i < ans.size(); i++){
cout << ans[i] << endl;
}
}
} |
#include <iostream>
using namespace std;
int main()
{
int h,w,t,maxh=0,maxw=0;
long taikakusen[200][200],max=0;
//??¢?´¢ i=w j=h
for(int i=1;i<=150;i++){
for(int j=1;j<i;j++){
taikakusen[i][j] = i*i + j*j;
}
}
cin>>h>>w;
while(h != 0 && w != 0){
t = h*h + w*w;
for(int i=1;i<=150;i++){
for(int j=1;j<i;j++){
if(t<taikakusen[i][j]){
if(max==0){
maxh=j;
maxw=i;
max=taikakusen[i][j];
}
else if(taikakusen[i][j]==max){
if(j<maxh){
maxh=j;
maxw=i;
}
}
else if(taikakusen[i][j]<max){
maxh=j;
maxw=i;
max=taikakusen[i][j];
}
}
if(t==taikakusen[i][j] && j>h){
maxh=j;
maxw=i;
max=taikakusen[i][j];
}
}
}
cout<<maxh<<" "<<maxw<<"\n";
maxh=0;
maxw=0;
max=0;
cin>>h>>w;
}
return 0;
} | 0 |
#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <vector>
#include <sstream>
#include <memory>
#include <iomanip>
std::vector<int> parse_line(std::string const& line) {
using namespace std;
vector<int> result;
istringstream s(line);
string element;
while (getline(s, element, ' ')) {
stringstream buf;
int value = 0;
buf << element;
buf >> value;
result.push_back(value);
}
return std::move(result);
}
int main(int argc, char* argv[])
{
using namespace std;
while (true) {
string line;
getline(std::cin, line);
auto elements = parse_line(line);
auto length = elements[0];
if (length == 0) break;
vector<int> total(length + 1);
size_t width = length + 1;
for (size_t i = 0; i < length; ++i) {
getline(cin, line);
elements = parse_line(line);
int sum = 0;
for (size_t n = 0; n < length; ++n) {
int val = elements[n];
sum += val;
total[n] += val;
cout << setw(5) << val;
}
cout << setw(5) << sum << endl;
total[length] += sum;
}
for (size_t i = 0; i < width; ++i) {
cout << setw(5) << total[i];
}
cout << endl;
}
return 0;
} | #include <iostream>
#include <cstring>
using namespace std;
int main(){
int n;
while(cin>>n,n){
int t[n+1][n+1];
memset(t,0,sizeof(t));
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin>>t[i][j];
t[i][n] += t[i][j];
t[n][j] += t[i][j];
t[n][n] += t[i][j];
}
}
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
printf("%5d",t[i][j]);
}
printf("\n");
}
}
} | 1 |
//Author:xht37
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector <int>
#define pb push_back
#define pq priority_queue
#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)
using namespace std;
namespace io {
const int SI = 1 << 21 | 1;
char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
int f, t;
#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
inline void flush() {
fwrite(OB, 1, OS - OB, stdout), OS = OB;
}
inline void pc(char x) {
*OS++ = x;
if (OS == OT) flush();
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
x *= f;
}
template <class I>
inline void rd(I &x, I &y) {
rd(x), rd(y);
}
template <class I>
inline void rd(I &x, I &y, I &z) {
rd(x), rd(y), rd(z);
}
template <class I>
inline void rda(I *a, int n) {
for (int i = 1; i <= n; i++) rd(a[i]);
}
inline void rdc(char &c) {
for (c = gc(); c < 33 || c > 126; c = gc());
}
inline void rds(char *s, int &n) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (n = 0; c >= 33 && c <= 126; s[++n] = c, c = gc());
s[n+1] = '\0';
}
inline void rds(string &s) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (s.clear(); c >= 33 && c <= 126; s.pb(c), c = gc());
}
template <class I>
inline void print(I x, char k = '\n') {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) ch[++t] = x % 10 + '0', x /= 10;
while (t) pc(ch[t--]);
pc(k);
}
template <class I>
inline void print(I x, I y) {
print(x, ' '), print(y);
}
template <class I>
inline void print(I x, I y, I z) {
print(x, ' '), print(y, ' '), print(z);
}
template <class I>
inline void printa(I *a, int n) {
for (int i = 1; i <= n; i++) print(a[i], " \n"[i==n]);
}
inline void printc(char c) {
pc(c);
}
inline void prints(char *s, int n) {
for (int i = 1; i <= n; i++) pc(s[i]);
pc('\n');
}
inline void prints(string s) {
int n = s.length();
while (t < n) pc(s[t++]);
pc('\n'), t = 0;
}
struct Flush {
~Flush() {
flush();
}
} flusher;
}
using io::rd;
using io::rda;
using io::rdc;
using io::rds;
using io::print;
using io::printa;
using io::printc;
using io::prints;
const int N = 1e5 + 7;
int n, ans;
pi a[N];
int l[N], r[N];
int main() {
// fl("1");
rd(n);
for (int i = 1; i <= n; i++) rd(a[i].fi, a[i].se);
sort(a + 1, a + n + 1);
l[0] = r[n+1] = 1e9;
for (int i = 1; i <= n; i++) l[i] = min(a[i].se, l[i-1]);
for (int i = n; i; i--) r[i] = min(a[i].se, r[i+1]);
for (int i = 1; i <= n; i++)
ans = max(ans, a[i].se - a[i].fi + 1 + max(0, min(l[i-1], r[i+1]) - a[n-(i==n)].fi + 1));
for (int i = 1; i < n; i++)
if (a[i].fi <= l[i] && a[n].fi <= r[i+1])
ans = max(ans, l[i] - a[i].fi + 1 + r[i+1] - a[n].fi + 1);
print(ans);
return 0;
} | //
// main.c
// ITP1_4_D
//
// Created by ??±??°?????? on 2015/09/29.
// Copyright ?? 2015??´ HamadaShogo. All rights reserved.
//
#include <stdio.h>
#include <stdlib.h>
long long intSum(int *num, int size);
int intMax(int *num, int size);
int intMin(int *num, int size);
int main(int argc, const char * argv[]) {
int *num;
int size;
long long sum;
int max;
int min;
int i;
scanf("%d", &size);
num = (int *)malloc(sizeof(int) * size);
if (num == NULL) {
printf("?????¢???????¢??????§????????????\n");
exit(1);
}
for (i=0; i<size; i++) {
scanf("%d", &num[i]);
}
sum = intSum(num, size);
max = intMax(num, size);
min = intMin(num, size);
printf("%d %d %lld\n", min, max, sum);
free(num);
return 0;
}
long long intSum(int *num, int size){
int i;
long long sum = 0;
for(i=0; i<size; i++){
sum += num[i];
}
return sum;
}
int intMax(int *num, int size){
int i;
int max = num[0];
for (i=0; i<size; i++) {
if (max < num[i]) {
max = num[i];
}
}
return max;
}
int intMin(int *num, int size){
int i;
int min = num[0];
for (i=0; i<size; i++) {
if (num[i] < min) {
min = num[i];
}
}
return min;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.