code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
#define name "bai3"
#define pii pair<int,int>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define fto(i,a,b) for(int i=a; i<=b; ++i)
#define maxn 100009
#define ll long long
using namespace std;
const int mod=1e9+7;
int n,a[maxn*2],xd[maxn*2];
ll p[maxn];
//ll q[maxn*2];
/*ll mu(int a, int b){
if(b==0) return 1;
ll tg=mu(a,b/2);
tg=(tg*tg)%mod;
if(b%2)tg=(tg*a)%mod;
return tg;
}
ll c(int a, int b){
///return b!/(a!*(b-a)!)
if(a==0)return 0;
if(a>b)return 0;
return (((p[b]*q[a])%mod)*q[b-a])%mod;
}*/
int main()
{
cin >> n;
int s=0;
p[0]=1;
fto(i,1,n)p[i]=(p[i-1]*i)%mod;
/*q[0]=1;
q[1]=1;
fto(i,2,n*2) q[i]=mu(p[i],mod-2);*/
fto(i,1,n*2){
char c;
cin >> c;
if(c=='B')a[i]=1;
else a[i]=0;
if(a[i]==s){
xd[i]=-1;
}
else{
xd[i]=1;
}
s^=1;
}
int s1=0,s2=0;
ll res=1;
fto(i,1,n*2)
if(xd[i]==1)++s1;
else{
if(s1>s2)res=(res*(s1-s2))%mod;
else res=0;
if(res==0)break;
++s2;
}
if(s1!=s2)res=0;
cout << res*p[n]%mod;
return 0;
}
/*
BWWB
WWWW
*/
| typedef long long ll;
typedef long double ld;
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main() {
ll n;
string s;
std::cin >> n>>s;
ll rc = 0;
string c = "L";
for (int i = 1; i < n*2; i++) {
if(s[i]!=s[i-1]){
if(c[i-1]=='R'){
c += 'R';
rc++;
}else{
c += 'L';
}
}else{
if(c[i-1]=='R'){
c += 'L';
}else{
c += 'R';
rc++;
}
}
}
if(s[0]=='W'){
std::cout << 0 << std::endl;
return 0;
}
if(rc!=n){
std::cout << 0 << std::endl;
return 0;
}
if(c[2*n-1]=='L'){
std::cout << 0 << std::endl;
return 0;
}
rc = 0;
ll ans = 1;
for (int i = 2*n-1; i >=0; i--) {
if(c[i]=='R'){
rc++;
}else{
if(rc==0){
std::cout << 0 << std::endl;
return 0;
}
ans *= rc;
rc--;
ans %= MOD;
}
}
for (int i = 0; i < n; i++) {
ans *= i+1;
ans %= MOD;
}
std::cout << ans << std::endl;
} | 1 |
// 7/3
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;
using P = pair<int, int>;
int main() {
// ll N, A, B, C, D, E;
// cin >> N >> A >> B >> C >> D >> E;
ll N, A[5];
cin >> N;
rep(i, 5) cin >> A[i];
sort(A, A + 5);
ll mn = A[0];
cout << (N + mn - 1) / mn + 4 << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
ll mn = min({a, b, c, d, e});
ll m = (n+mn-1)/mn;
ll ans = m + 4;
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define F first
#define S second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
const int N = 1e5 + 123;
int n;
ll a[N];
vector <ll> basis;
void add(ll x) {
for (ll i : basis) {
x = min(x, x ^ i);
}
if (x > 0) {
basis.pb(x);
}
}
int f(ll x) {
for (int i = 59; i >= 0; i--) {
if (x >> i & 1) {
return i;
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
cin >> n;
ll t = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
t ^= a[i];
}
ll ans = t, rt = t ^ ((1ll << 60) - 1);
for (int i = 1; i <= n; i++) {
a[i] &= rt;
add(a[i]);
}
sort(all(basis));
reverse(all(basis));
ll res = 0;
for (ll i : basis) {
if (res >> f(i) & 1) {
continue;
}
res ^= i;
}
ans += 2 * res;
cout << ans;
}
| //include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <stdexcept>
using namespace std;
// type alias
using ll = long long;
using ull = unsigned long long;
//conversion
//------------------------------------------
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }
//debug
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) cerr << #x << " = " << (x) << " (l" << __line__ << ")" << " " << __file__ << endl
inline ll floor(ll a, ull b)
{
ll llb = b;
if (a >= 0)
{
return a / llb;
}
else
{
return - ( (-a + llb - 1) / llb);
}
}
inline ll ceil(ll a, ull b)
{
ll llb = b;
if (a >= 0)
{
return (a + llb - 1) / llb;
}
else
{
return - (-a / llb);
}
}
inline ll getLowestOneBit(ll a)
{
return a & (-a);
}
inline ll getHighestOneBit(ll a)
{
while ((a & (a - 1)) != 0)
{
a = a & (a - 1);
}
return a;
}
inline bool isPower2(ull a)
{
if (a == 0)
{
return false;
}
return !(a & (a - 1));
}
inline ll getSpecifiedBit(ll a, unsigned bit)
{
return (a & (1LL << bit)) >> bit;
}
// computational complexity: o(log(max(a, b)))
inline ull getGcd(ull a, ull b)
{
if (b == 0)
{
return a;
}
return getGcd(b, a % b);
}
template<class Integer>
inline Integer getPower(Integer base, ull exponential)
{
Integer result = 1;
while (exponential >= 1)
{
if (exponential & 1)
{
result = result * base;
}
base = base * base;
exponential >>= 1;
}
return result;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<vector<ll>> As(N, vector<ll>(60));
vector<ll> bit_count(60);
ll a;
for (ll i = 0; i < N; ++i)
{
cin >> a;
for (ll j = 0; j < 60; ++j)
{
As[i][j] = (a & (1LL << j)) >> j;
bit_count[j] += (a & (1LL << j)) >> j;
}
}
ll res = 0;
for (ll j = 0; j < 60; ++j)
{
if (bit_count[j] % 2 != 0)
{
res += 1LL << j;
for (ll i = 0; i < N; ++i)
{
As[i][j] = 0;
}
}
}
ll row = 0;
for (ll j = 59; j >= 0; --j)
{
if (bit_count[j] % 2 != 0) continue;
for (ll i = row; i < N; ++i)
{
if (As[i][j] == 0) continue;
vector<ll> temp = As[row];
As[row] = As[i];
As[i] = temp;
for (ll k = row + 1; k < N; ++k)
{
if (As[k][j] == 0) continue;
for (ll l = 0; l < 60; ++l)
{
As[k][l] = (As[k][l] - As[row][l] + 2LL) % 2LL;
}
}
++row;
break;
}
}
vector<ll> f2_vec(60);
row = 0;
for (ll j = 59; j >= 0; --j)
{
if (As[row][j] == 0) continue;
if (f2_vec[j] == 0)
{
for (ll k = 0; k < 60; ++k)
{
f2_vec[k] = (f2_vec[k] + As[row][k] + 2LL) % 2;
}
}
++row;
}
for (ll j = 0; j < 60; ++j)
{
if (f2_vec[j] == 1)
{
res += (1LL << j) * 2;
}
}
cout << res << endl;
return 0;
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ull B = 100000007;
ll mod = 1000000007;
int INF = 0x3f3f3f3f;
int main() {
int n, m;
cin >> n >> m;
vector<int> v(n+1);
int u1 = 1+m;
int d1 = 1;
int u2= n;
int d2 = n - m + 1;
int c = 0;
while (u1 > d1 && c < m) {
cout << u1 << " " << d1 << endl;
d1++; u1--;
c++;
}
while (u2 > d2 && c < m) {
cout << u2 << " " << d2 << endl;
d2++; u2--;
c++;
}
}
| #include <iostream>
#include <algorithm>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
int l[n];
for (int i=0; i<n; ++i)
cin >> l[i];
sort(l, l+n);
int ans = 0;
for (int i=0; i<k; ++i)
ans += l[n-1-i];
cout << ans;
}
int main() {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for(int i=0; i<(a); i++)
typedef long long ll;
#ifdef _DEBUG
inline void dump() { cerr << endl; }
template<typename Head> void dump(Head&& head) { cerr << head; dump(); }
template<typename Head, typename... Tail> void dump(Head&& head, Tail&&... tail) { cerr << head << ", "; dump(forward<Tail>(tail)...); }
#define debug(...) do {cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; dump(__VA_ARGS__); } while (false)
#else
#define dump(...)
#define debug(...)
#endif
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>>;
/////////////////////////////////////////////////////////////////////
const ll inf = 1LL<<60;
typedef pair<ll, ll> P;
int main()
{
ll n; cin>>n;
vector<ll> a(n);
vector<ll> b(n);
vector<P> c(n);
rep(i, n) {
cin>>a[i]>>b[i];
c[i] = make_pair(a[i]+b[i], i);
}
sort(c.rbegin(),c.rend());
ll x=0, y=0;
rep(i, n) {
if (i%2) y += b[c[i].second];
else x += a[c[i].second];
}
cout << x-y << endl;
return 0;
}
| #include <iostream>
#include <cstring>
using namespace std;
#define N 8
bool col[N],hi[2*N-1],mi[2*N+1];
int row[N];
void point(int y,int x){
row[y] = x;
col[x] = false;
hi[x+y] = false;
mi[y-x+N-1] = false;
}
void del(int y, int x){
row[y] = -1;
col[x] = true;
hi[x+y] = true;
mi[y-x+N-1] = true;
}
void print_ans(){
for(int i=0; i<N; i++){
for(int j=0; j<N; j++){
if(row[i] == j) cout << "Q";
else cout << ".";
}
cout << endl;
}
}
bool is_ok(int y,int x){
return row[y] == -1 && col[x] == true && hi[x+y] == true && mi[y-x+N-1];
}
void dfs(int r){
if(r == 8){//??´??????
print_ans();
return ;
}
if(row[r] != -1){
dfs(r+1);
}
else{
for(int i=0; i<8; i++){
if(is_ok(r,i) == true){
point(r,i);
dfs(r+1);
del(r,i);
}
}
}
return;
}
int main(){
int k; cin >> k;
memset(row,-1,sizeof(row));
memset(col,true,sizeof(col));
memset(hi,true,sizeof(hi));
memset(mi,true,sizeof(mi));
for(int i=0; i<k; i++){
int x,y; cin >> y >> x;
row[y] = x;
col[x] = false;
hi[x+y] = false;
mi[y-x+N-1] = false;
}
dfs(0);
} | 0 |
#include<bits/stdc++.h>
using namespace std;
///Welcome to Nasif's Code
#define bug printf("bug\n");
#define bug2(var) cout<<#var<<" "<<var<<endl;
#define co(q) cout<<q<<endl;
#define all(q) (q).begin(),(q).end()
typedef long long int ll;
typedef unsigned long long int ull;
const int MOD = (int)1e9+7;
const int MAX = 1e6;
#define pi acos(-1)
#define inf 1000000000000000LL
#define FastRead ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
map<int,int>mp;
bool check(int n)
{
while(n>0){
int cur=n%10;
n/=10;
if(mp[cur])
return 0;
}
return 1;
}
int main()
{
FastRead
//freopen("output.txt", "w", stdout);
int n,k;
cin>>n>>k;
for(int i=0; i<k; i++)
{
int a;
cin>>a;
mp[a]++;
}
for(int i=n; i<=MAX; i++)
{
if(check(i))
{
cout<<i<<endl;
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#include <math.h>
#include <iostream>
#include <numeric>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y)
int INF = 1e9;
int main(){
int n,K;cin >> n >> K;
vector<int> num;
rep(i,10) num.push_back(i);
rep(i,K) {
int a;cin >> a;
rep(j,num.size()){
if(num[j]==a) num.erase(num.begin()+j);
}
}
//rep(i,num.size()) cout << num[i]<< endl;
int ans = 100000;
for(int a:num)for(int b:num)for(int c:num)for(int d:num)for(int e:num){
int temp = 10000*a+1000*b+100*c+10*d+e;
int temp2 = 1000*b+100*c+10*d+e;
int temp3 = 100*c+10*d+e;
int temp4 = 10*d+e;
int temp5 = e;
if(temp >= n) ans = min(ans,temp);
if(temp2 >= n) ans = min(ans,temp2);
if(temp3 >= n) ans = min(ans,temp3);
if(temp4 >= n) ans = min(ans,temp4);
if(temp5 >= n) ans = min(ans,temp5);
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include<vector>
#include<array>
#include<cmath>
#include <algorithm>
using namespace std;
int main() {
// 初期処理(iostream軽くする)
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
string n;
cin >> n;
if (n.find("7") != string::npos) {
cout << "Yes";
}
else {
cout << "No";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
vector<pair<int,int> >bara,koma;
bool comp1(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.second<b.second);
}
bool comp2(const pair<ll,ll> &a, const pair<ll,ll> &b){
return (a.first>b.first);
}
int main()
{
int t;
cin>>t;
int open,close;
while(t--)
{
string s;
cin>>s;
open=0;
close=0;
for(char c : s)
{
if(c=='(')
{
open++;
}
else
{
if(open)
open--;
else
close++;
}
}
if(open>=close)
bara.push_back({open,close});
else
koma.push_back({open,close});
}
sort(bara.begin(), bara.end(),comp1);
sort(koma.begin(),koma.end(),comp2);
bara.insert(bara.end(),koma.begin(),koma.end());
int ans=0;
for(auto x : bara)
{
ans-=x.second;
if(ans<0)
{
cout<<"No"<<endl;
return 0;
}
ans+=x.first;
}
if(ans==0)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
typedef priority_queue<int> HEAP;
typedef priority_queue<int, vector<int>, greater<int> > RHEAP;
const int N = 100010, M = 1010;
int n;
int q[N];
int main()
{
scanf("%d", &n);
int cnt = 0;
for (int i = 1; i <= n; i ++ )
{
int x;
scanf("%d", &x);
int l = 1, r = cnt;
while (l < r)
{
int mid = l + r >> 1;
if (q[mid] < x) r = mid;
else l = mid + 1;
}
if (!cnt || q[cnt] >= x) q[ ++ cnt] = x;
else q[r] = x;
}
printf("%d\n", cnt);
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge=pair<int,int>;
using Graph=vector<vector<int>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return 1;}return 0;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
int main(){
int N;
cin>>N;
int A[N];
multiset<int> M;
REP(i,N){
cin>>A[i];
auto it=M.lower_bound(A[i]);
if(it!=M.begin()) M.erase(--it);
M.insert(A[i]);
}
co(M.size());
} | 1 |
/* Simplicity and Goodness */
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
void my_dbg() { cout << endl; }
template<typename Arg, typename... Args> void my_dbg(Arg A, Args... B)
{ cout << ' ' << A; my_dbg(B...); }
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", my_dbg(__VA_ARGS__)
#define scn(n) scanf("%d", &n)
#define lscn(n) scanf("%lld", &n)
#define pri(n) printf("%d ", (int)(n))
#define prin(n) printf("%d\n", (int)(n))
#define lpri(n) printf("%lld ", n)
#define lprin(n) printf("%lld\n", n)
#define rep(i,a,b) for(int i=(int)(a); i<(int)(b); i++)
#define pb push_back
#define mp make_pair
#define F first
#define S second
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
const int inf = INT_MAX;
const int ninf = INT_MIN;
const int mod = 1e9+7;
const int N = 2e5+2;
void solve()
{
string st;
cin >> st;
int s = 0, t = 0, rm = 0;
rep(i, 0, st.size()) {
if(st[i] == 'S')
s ++, t = 0;
else
t ++;
if(st[i] == 'T') {
int here = min(s, t);
s -= here;
t -= here;
rm += here;
}
}
prin(st.size() - rm * 2);
}
int main()
{
int t = 1;
// scn(t);
while(t --) {
solve();
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define pii pair<int,int>
string S;
signed main()
{
cin >> S;
int tmp = 0;
int ans = S.size();
for(auto e : S)
{
if(e == 'T' && tmp)
{
tmp--;
ans -= 2;
}
if(e == 'S')tmp++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define fo(i,a,b) for(register int (i)=(a);(i)<=(b);++(i))
#define rd read()
#define maxn 200001
#define gc getchar()
#define mem(a,b) memset(a,b,sizeof(a))
#define mp make_pair
#define ll long long
#define ull unsigned ll
#define pb push_back
#define db double
#define pu puts(" ")
using namespace std;
const int p=998244353;
int read()
{
int x=0,f=1;
char ch=gc;
while(!isdigit(ch))
{
if(ch=='-')f=-1;
ch=gc;
}
while(isdigit(ch))x=x*10+ch-48,ch=gc;
return x*f;
}
void print(int x)
{
if(x<0)putchar('-'),x=-x;
if(x>9)print(x/10);
putchar(x%10+48);
}
int qp(int a,int b)
{
int ans=1;
while(b)
{
if(b&1)ans=(ll)ans*a%p;
a=(ll)a*a%p;
b>>=1;
}
return ans%p;
}
int main()
{
int a=rd,b=rd,k=rd;
fo(i,1,k)
{
if(i%2==1)
{
if(a%2==1)a--;a/=2,b+=a;}
else{if(b%2==1)b--;b/=2,a+=b;}
}
printf("%d %d\n",a,b);
return 0;
} | #include <iostream>
#include <fstream>
#include <cstdlib>
#include <math.h>
#include <utility>
#include <algorithm>
#include <functional>
#include <vector>
#include <numeric>
#include <bits/stdc++.h>
#define int long long
struct edge {
int to;
int cost;
};
using namespace std;
using vi = vector<int>;
using vii = vector<vector<int>>;
using vb = vector<bool>;
using qi = queue<int>;
using P = pair<int, int>;
using graph = vector<vector<edge>>;
// using graph = vector<vector<int>>;
#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define REP(i,n) for(int i=0;i<n;i++)
#define delim(i, n) cout << (i == n-1 ? "\n" : " ");
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const int inf = 1LL << 60;
// const int inf = 100000000;
const int mod = 1000000007;
const int maxn = 100000;
int n, m;
vi a(maxn);
vi table(maxn);
vi dx = {-1, 0, 0, 1};
vi dy = {0, -1, 1, 0};
int lds() {
table.resize(n);
REP(i, n) {
table[i] = -1;
}
REP(i, n) {
auto iter = upper_bound(table.begin(), table.end(), a[i], [](const int& a, const int& b) { return a > b; });
*iter = a[i];
}
auto iter = lower_bound(table.begin(), table.end(), -1, [](const int& a, const int& b) { return a > b; });
return (int) (iter - table.begin());
}
signed main () {
cin.tie(0);
ios::sync_with_stdio(false);
// https://onlinejudge.u-aizu.ac.jp/problems/DPL_1_D
cin >> n;
REP(i, n) {
cin >> a[i];
}
int ret = lds();
cout << std::fixed << std::setprecision(10) << ret << "\n";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
long long ans = 0, mul = a[0];
for (int i = 1; i < n; i++){
ans += (mul * a[i]) % MOD;
ans %= MOD;
mul += a[i];
mul %= MOD;
}
cout << ans << '\n';
return 0;
}
| #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define gc getchar_unlocked
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(int i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long int
#define s(x) cin>>x
#define p(x) cout<<x<<"\n"
#define goog(x, y) cout<<"Case #"<<x<<": "<<y<<"\n"
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define INF 100000000000
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef long double ld;
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0,lim-1);
return uid(rang);
}
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
int gcd(int a, int b) ;
const int mod = 1'000'000'007;
const int N = 3e5, M = N;
//=======================
vi g[N];
int a[N];
void solve() {
int n;cin>>n;
ll a[n];
fo(i,n) cin>>a[i];
ll cont[n];
cont[0]=a[0];
Fo(i,1,n)
cont[i]=(cont[i-1]+a[i])%mod;
ll res[n];
res[0]=0;
Fo(i,1,n)
{ res[i]=(res[i-1]+a[i]*cont[i-1])%mod;}
p(res[n-1]);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
//cin >> t;
while(t--) {
solve();
}
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((ll)result * base) % mod;
base = ((ll)base * base) % mod;
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m){
int i, u, v;
while(m--){
cin>>u>>v;
//u--, v--;
g[u].pb(v);
g[v].pb(u);
}
}
void dfs(int u, int par){
for(int v:g[u]){
if (v == par) continue;
dfs(v, u);
}
}
int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
// Macros for easier access
#define ll long long
#define endl '\n'
#define F first
#define S second
#define umap unordered_map
#define uset unordered_set
#define test ll cases; cin>>cases; for(ll testCase = 1; testCase <= cases; testCase++) //test cases
#define fill(name, val) memset(name, val, sizeof(name));
#define mop(a, op, b) (a%mod op b%mod)%mod
#define error(x) fixed<<setprecision(x) //cout<<error(5)<<someDouble -> example - 3.14159
#define vll vector<ll>
#define vvll vector<vll>
#define pll pair<ll, ll>
#define get(a, n) for(ll it = 0; it < n; it++) cin>>a[it];
#define boost ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define debug(x) cerr << #x << " : " << (x) << endl
// Constants
#define MX 100001
#define mod 1000000007LL
#define inf 1000000000000000000LL
void init(){
boost;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
/* Author: 🆉🅴🅽🅾🅻🆄🆂 */
string k;
ll dp[10001][2][101], d;
ll count(ll i, bool tight, ll sum){
if(i == k.size()) return (sum == 0);
if(dp[i][tight][sum] != -1) return dp[i][tight][sum];
ll ans = 0, high = tight ? k[i]-'0' : 9;
for(ll j = 0; j <= high; j++)
ans = mop(ans, +, count(i+1, tight & (j == high), (sum+j)%d));
return dp[i][tight][sum] = ans;
}
int main(){
init(); fill(dp, -1);
cin>>k>>d;
cout<<(count(0, 1, 0) + mod - 1) % mod;
}
| #include <bits/stdc++.h>
#include <iostream>
//#include <algorithm>
// #include <iomanip>
#define ll long long
#define map unordered_map
#define set unordered_set
#define pll pair<ll, ll>
#define vll vector<ll>
#define mll map<ll, ll>
using namespace std;
const ll MOD = 1000000007LL;
const ll INF = (1LL << 60LL);
ll m[100][100];
void show_table(ll I, ll J) {
for (ll i = 0; i <= I; i++) {
for (ll j = 0; j <= J; j++) {
cout << m[i][j] << " ";
}
cout << "" << endl;
}
cout << "" << endl;
}
int main() {
// std::cout << std::fixed << std::setprecision(10);
ll H, W;
scanf("%lld %lld", &H, &W);
for (ll y = 0; y < H; y++) {
for (ll x = 0; x < W; x++) {
m[y][x] = -1;
}
}
ll spaces = 0;
for (ll y = 0; y < H; y++) {
string s;
cin >> s;
for (ll x = 0; x < W; x++) {
if (s[x] == '.') {
m[y][x] = INF;
spaces++;
}
}
}
queue<pll> q;
q.push(make_pair(0, 0));
m[0][0] = 0;
for (;;) {
if (q.empty()) {
break;
}
auto pos = q.front();
ll y = pos.first;
ll x = pos.second;
ll c = m[y][x];
if (y >= 1 && m[y - 1][x] > c + 1) {
m[y - 1][x] = c + 1;
q.push(make_pair(y - 1, x));
}
if (y < H - 1 && m[y + 1][x] > c + 1) {
m[y + 1][x] = c + 1;
q.push(make_pair(y + 1, x));
}
if (x >= 1 && m[y][x - 1] > c + 1) {
m[y][x - 1] = c + 1;
q.push(make_pair(y, x - 1));
}
if (x < W - 1 && m[y][x + 1] > c + 1) {
m[y][x + 1] = c + 1;
q.push(make_pair(y, x + 1));
}
q.pop();
}
// show_table(3, 3);
ll a = m[H - 1][W - 1];
if (a == INF) {
cout << -1 << endl;
return 0;
}
// cout << "a:" << a << endl;
ll ans = spaces - a - 1;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define rrep(i, a) for (int i = (int)a - 1; i >= 0; --i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define RREP(i, a, b) for (int i = (int)a - 1; i >= b; --i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define popcount __builtin_popcount
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
ll gcd(ll n, ll m)
{
ll tmp;
while (m != 0)
{
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m)
{
return abs(n) / gcd(n, m) * abs(m); //gl=xy
}
using namespace std;
void solve(){
int n;
cin>>n;
string s;
cin>>s;
int q;
cin>>q;
vector<ll>cnt_m(n+1);
rep(i,n){
cnt_m[i+1]=cnt_m[i]+ll(s[i]=='M');
}
while(q--){
int k;
cin>>k;
vector<vector<ll>>dp(2,vector<ll>(4));
dp[0][0]=1;
rep(i,k){
rep(j,4){
dp[(i+1)%2][j]+=dp[i%2][j];
}
if(s[i]=='D'){
dp[(i+1)%2][1]+=dp[i%2][0];
}
else if(s[i]=='M'){
dp[(i+1)%2][2]+=dp[i%2][1];
}
else if(s[i]=='C'){
dp[(i+1)%2][3]+=dp[i%2][2];
}
rep(j,4)dp[i%2][j]=0;
}
for(int i=k;i<n;++i){
if(s[i-k]=='D'){
dp[i%2][2]-=(cnt_m[i]-cnt_m[i+1-k]);
dp[i%2][1]--;
}
rep(j,4){
dp[(i+1)%2][j]+=dp[i%2][j];
}
if(s[i]=='D'){
dp[(i+1)%2][1]+=dp[i%2][0];
}
else if(s[i]=='M'){
dp[(i+1)%2][2]+=dp[i%2][1];
}
else if(s[i]=='C'){
dp[(i+1)%2][3]+=dp[i%2][2];
}
rep(j,4)dp[i%2][j]=0;
}
cout<<dp[n%2][3]<<"\n";
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| #include "bits/stdc++.h"
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
int main() {
int N, Q;
string S;
cin >> N >> S >> Q;
vector<int> k(Q);
rep(i, Q) cin >> k[i];
rep(i, Q) {
ll ans = 0;
vector<ll> D(N + 1, 0), M(N + 1, 0), DM(N + 1, 0);
rep(j, N) {
D[j + 1] = D[j];
M[j + 1] = M[j];
DM[j + 1] = DM[j];
if (S[j] == 'D') D[j + 1]++;
if (j >= k[i] && S[j - k[i]] == 'D') {
D[j + 1]--;
DM[j + 1] -= M[j + 1];
}
if (S[j] == 'M') {
M[j + 1]++;
DM[j + 1] += D[j + 1];
}
if (j >= k[i] && S[j - k[i]] == 'M') M[j + 1]--;
if (S[j] == 'C') ans += DM[j + 1];
//cout << "j=" << j << " D=" << D[j + 1] << " M=" << M[j + 1] << " DM=" << DM[j + 1] << "\n";
}
cout << ans << "\n";
}
} | 1 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef string str;
typedef vector<ll> vel;
typedef vector<str> ves;
#define REP(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rep(i, b) REP(i, 0, b)
const ll mod = 1000000007;
const double pi = 3.14159265358979;
ll expo(ll a, ll b){
ll ex = 1;
rep(i, b){
ex *= a;
}
return ex;
}
ll fact(ll a){
ll fc = 1;
REP(i, 1, a+1){
fc *= i;
}
return fc;
}
int main() {
ll a, b;
cin >> a >> b;
cout << max(a+b, max(a-b, a*b)) << endl;
} | #include <iostream>
using namespace std;
int main()
{
int A, B;
cin >> A >> B;
int X = A*B;
int Y = A+B;
int Z = A-B;
if((X>=Y)&&(X>=Z))
{
cout << X;
}
else if((Y>=X)&&(Y>=Z))
{
cout << Y;
}
else if((Z>=Y)&&(Z>=X))
{
cout << Z;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a <= b && c <= d) {
cout << a + c << "\n";
} else if (a <= b && c >= d) {
cout << a + d << "\n";
} else if (a >= b && c >= d) {
cout << b + d << "\n";
} else if (a >= b && c <= d) {
cout << b + c << "\n";
}
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,d,ans;
while(cin >> a >> b >> c >> d){
ans = 0;
ans+=min(a,b);
ans+=min(c,d);
cout << ans << endl;
}
}
| 1 |
// Graph: Adjacency list
#include<vector>
typedef std::vector<std::vector<int>> Graph;
// Utility
const Graph reverse(const Graph& g) {
Graph result(g.size());
for(int u = 0; u < g.size(); ++u) for(auto v: g.at(u)) result.at(v).push_back(u);
return result;
}
void postorder_dfs(const Graph& g, int current, std::vector<bool>& visited, std::vector<int>& result) {
visited.at(current) = true;
for(auto next: g.at(current)) if(!visited.at(next)) postorder_dfs(g, next, visited, result);
result.push_back(current);
}
std::vector<int> postorder(const Graph& g) {
std::vector<bool> visited(g.size(), false);
std::vector<int> result;
for(int v = 0; v < g.size(); ++v) if(!visited[v]) postorder_dfs(g, v, visited, result);
return result;
}
// Strongly Connected Components: Kosaraju's algorithm O(V + E)
void scc_dfs(const Graph& g, int current, int group, std::vector<bool>& visited, std::vector<int>& result) {
visited.at(current) = true;
result.at(current) = group;
for(auto next: g.at(current)) if(!visited.at(next)) scc_dfs(g, next, group, visited, result);
}
std::vector<int> scc(const Graph& g) {
auto order = postorder(g);
auto rg = reverse(g);
std::vector<bool> visited(g.size(), false);
std::vector<int> result(g.size());
int group = 0;
for(auto v = order.rbegin(); v != order.rend(); ++v) if(!visited.at(*v)) scc_dfs(rg, *v, group++, visited, result);
return result;
}
#include<bits/stdc++.h>
using namespace std;
int main() {
int V, E;
cin >> V >> E;
Graph g(V);
for(int i = 0; i < E; ++i) {
int s, t;
cin >> s >> t;
g[s].push_back(t);
}
auto group = scc(g);
int Q;
cin >> Q;
for(int i = 0; i < Q; ++i) {
int u, v;
cin >> u >> v;
cout << (group[u] == group[v] ? 1 : 0) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
const ll MOD = 1e9 + 7;
const ll INF = 1e16;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
void init() {cin.tie(0);ios::sync_with_stdio(false);cout << fixed << setprecision(15);}
//--------------------------------------------------------------------------------//
int main() {
init();
ll N, M;
cin >> N >> M;
vvc<ll> E(N), R(N);
vc<ll> inn(N); //根なら0のまま
rep(i,N-1+M){
ll a, b;
cin >> a >> b;
a--, b--;
E[a].eb(b);
inn[b]++;
}
ll root;
rep(i, N) if (inn[i]==0){
root = i;
break;
}
vl dep(N), ans(N), cnt(N);
queue<ll> q;
q.emplace(root);
while(!q.empty()){
ll now = q.front();
q.pop();
cnt[now]++;
if (cnt[now] < inn[now]) continue; //親から辿られきられていないなら飛ばす
for(auto to:E[now]){
dep[to] = dep[now] + 1;
ans[to] = now+1;
q.emplace(to);
}
}
rep(i, N) cout << ans[i] << "\n";
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
string a,b,c; cin>>a>>b>>c;
int l=a.length(),r=b.length(),p=c.length();
if(a[l-1]==b[0] && b[r-1]==c[0])cout<<"YES";
else cout<<"NO";
}
| #include<bits/stdc++.h>
#define forr(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rrep(i,n) for(int i = 1; i <= (n); i++)
#define ALL(a) (a.begin()),(a.end())
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<ll, ll> LP;
const ll LINF = 1LL<<60;
const int INF = 1001001001;
const int MOD = 1000000007;
/* --------------------------------------------------- */
int main() {
int n;
string s, t;
cin >> n >> s >> t;
int ans = s.size() + t.size();
int tot = 0;
for(int i = n - 1; i >= 0; i--) {
bool check = true;
for(int j = i; j < n; j++) {
if(s[j] != t[j - i]) check = false;
}
if(check) tot = n - i;
}
cout << ans - tot << endl;
return 0;
} | 0 |
#include<iostream>
#include<string>
#include<vector>
#include<numeric>
#include<math.h>
#include<algorithm>
#include<iomanip>
#include<list>
#include<bitset>
#include<sstream>
using namespace std;
int main() {
vector<string> S(3, "");
for (long long i = 0; i < S.size(); i++) {
cin >> S[i];
}
vector<list<long long>> v(3, list<long long>());
for (long long i = 0; i < v.size(); i++) {
for (long long j = 0; j < S[i].length(); j++) {
if (S[i][j] == 'a') {
v[i].push_back(0);
}
else if (S[i][j] == 'b') {
v[i].push_back(1);
}
else {
v[i].push_back(2);
}
}
v[i].push_back(-1);
}
long long val = 0;
long long dval = 0;
while (v[0].size() * v[1].size() * v[2].size() != 0) {
dval = v[val].front();
v[val].pop_front();
val = dval;
}
for (long long i = 0; i < v.size(); i++) {
if (v[i].size() == 0) {
if (i == 0) {
cout << "A" << endl;
break;
}
else if (i == 1) {
cout << "B" << endl;
break;
}
else {
cout << "C" << endl;
break;
}
}
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, s, n) for (int i = s; i < (int)(n); i++)
#define out(x) cout << x << endl;
#define INF 1ll<<60;
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; }
using namespace std;
using ll = long long;
typedef pair<int, int> P;
int main(){
vector<string> s(3);
rep(i, 3) cin >> s[i];
int turn = 0;
while(true){
if(s[turn].empty()){
cout << char('A'+turn) << endl;
return 0;
}
int n_turn = s[turn][0] - 'a';
s[turn].erase(0, 1);
turn = n_turn;
}
return 0;
} | 1 |
#include <cstdio>
#include <algorithm>
using namespace std;
class Dice {
int num[6];
public:
void set(int n, int s) {
num[s] = n;
}
void move(char c) {
if (c == 'E') {
swap(num[0], num[3]);
swap(num[3], num[5]);
swap(num[5], num[2]);
}
else if (c == 'N') {
swap(num[0], num[1]);
swap(num[1], num[5]);
swap(num[5], num[4]);
}
else if (c == 'S') {
swap(num[0], num[4]);
swap(num[4], num[5]);
swap(num[5], num[1]);
}
else if (c == 'W') {
swap(num[0], num[2]);
swap(num[2], num[5]);
swap(num[5], num[3]);
}
}
int up() {
return num[0];
}
};
int main() {
Dice d;
int n;
for (int i = 0; i < 6; i++) {
scanf("%d", &n);
d.set(n, i);
}
getchar();
char c;
while (scanf("%c", &c), c != '\n') {
d.move(c);
}
printf("%d\n", d.up());
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
int a,b;
string s;
int main(void){
cin>>a>>b>>s;
for(int i=0;i<a+b+1;i++){
if(i==a){
if(s[i]!='-'){
cout<<"No"<<endl;
return 0;
}
}else{
if(s[i]=='-'){
cout<<"No"<<endl;
return 0;
}
}
}
cout<<"Yes"<<endl;
}
| 0 |
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <list>
#include <unordered_set>
#include <tuple>
#include <cmath>
#include <limits>
#include <type_traits>
#include <iomanip>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <regex>
#include <random>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n)for(ll i=0;i<n;++i)
#define exout(x) printf("%.12f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 1010101;
//組み合わせの余りを求める
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_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 COM(ll n, ll k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
//最大公約数
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)return 0;
return (x / gcd(x, y) * y);
}
ll dx[8] = { 1,-1,0,0,1,1,-1,-1 };
ll dy[8] = { 0,0,1,-1,1,-1,1,-1 };
ll d[110][2];
//long longしか使わない
//素数は1より大きい
//lower_boundは指定したkey以上の要素の一番左のイテレータをかえす
//upper_boundは指定したkeyより大きい要素の一番左のイテレータをかえす
int main() {
ll n, q;
cin >> n >> q;
string s;
cin >> s;
vector<ll>res(n);
rep(i, n - 1) {
res[i + 1] = res[i];
if (s[i] == 'A' && s[i + 1] == 'C')res[i + 1]++;
}
rep(i, q) {
ll l, r;
cin >> l >> r;
l--, r--;
cout << res[r] - res[l] << endl;
}
return 0;
}
| #include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<utility>
#include<cmath>
#include<string>
#include<cstring>
#include<map>
#include<queue>
#include<set>
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define prin(arg) std::cout<<arg<<"\n"
#define prin2(arg1,arg2) std::cout<<arg1<<" "<<arg2<<"\n"
#define fill(arg,n) std::memset(arg,n,sizeof(arg))
#define mp std::make_pair
#define pb push_back
using std::cin;
typedef long long ll;
typedef std::pair<int,int> pi;
typedef std::pair<int,pi> pipi;
typedef std::vector<int> vi;
typedef std::set<int> si;
typedef std::string str;
const int INF=1e+9;
const ll INFLL=1e+17;
const ll MOD=1e+9+7;
const int NMAX=200010;
int N,K,L;
int p[100010],q[100010],r[100010],s[100010];
//UnionFindTreeのクラス。
/***************************/
class uft{
public:
int par[NMAX];//親
int rank[NMAX];//木の深さ
int size[NMAX];//木の大きさ
uft(int n);//コンストラクタ
int find(int x);
void unite(int x,int y);
bool same(int x,int y);
int usize(int x);
};
uft::uft(int n){//コンストラクタ uft uf(N)でサイズNのunionfindtreeを宣言
for(int i=0;i<n;i++){
par[i]=i;
rank[i]=0;
size[i]=1;
}
}
int uft::find(int x){//xの根を返す
if(par[x]==x) return x;//根の親は自分自身
else return par[x]=find(par[x]);//再起で親を辿る
}
void uft::unite(int x,int y){//x,yを併合
x=find(x);
y=find(y);
if(x==y) return ;//根が同じなら併合する必要なし
if(rank[x]<rank[y]){//木の深い方に浅い方をつける
par[x]=y;
size[y]+=size[x];
}
else{
par[y]=x;
size[x]+=size[y];
if(rank[x]==rank[y]) rank[x]++;//同じ深さなら深さを増やす
}
}
bool uft::same(int x,int y){//x,yが同じグループにいるかどうかを返す
return find(x)==find(y);//根が同じかどうかを判断する
}
int uft::usize(int x){//xの属する木のサイズを返す
return size[find(x)];
}
int main(){
cin>>N>>K>>L;
rep(i,K){
cin>>p[i]>>q[i];
p[i]--;q[i]--;
}
rep(i,L){
cin>>r[i]>>s[i];
r[i]--;s[i]--;
}
uft ur(N),ut(N);
rep(i,K){
ur.unite(p[i],q[i]);
}
rep(i,L){
ut.unite(r[i],s[i]);
}
pipi p[200010];
rep(i,N){
p[i]=mp(ur.find(i),mp(ut.find(i),i));
}
std::sort(p,p+N);
int res[200010];
int cnt=1;
rep(i,N-1){
if(p[i].first==p[i+1].first&&p[i].second.first==p[i+1].second.first) cnt++;
else{
rep(j,cnt){
res[p[i-j].second.second]=cnt;
}
cnt=1;
}
}
rep(j,cnt){
res[p[N-1-j].second.second]=cnt;
}
rep(i,N){
std::cout<<res[i]<<" ";
}
std::cout<<"\n";
return 0;
}
| 0 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <ctime>
#include <cstring>
#include <functional>
#include <iostream>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <regex>
#include <vector>
#define fix(n) cout<<fixed<<setprecision(n)
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define sort(a) sort((a).begin(), (a).end())
#define uniq(a) SORT(a);(a).erase(unique((a).begin(), (a).end()), (a).end())
#define reverse(a) reverse((a).begin(), (a).end())
#define ctos(c) string(1, (c))
#define out(d) cout << (d)
#define outl(d) std::cout<<(d)<<"\n"
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
#define ceil(x, y) ((x + y - 1) / (y))
#define debug(x) cerr << #x << ": " << (x) << '\n'
#define debug2(x, y) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << '\n'
#define debug3(x, y, z) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << ", " << #z << ": " << (z) << '\n'
#define dbg(v) for (size_t _ = 0; _ < v.size(); ++_){ cerr << #v << "[" << _ << "] : " << v[_] << '\n'; }
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
const ll MOD = 1000000007; // 10^9 + 7
void solve() {
int n; cin >> n;
string a, b, c; cin >> a >> b >> c;
int ans = 0;
rep(i, n) {
set<char> s;
s.insert(a[i]);s.insert(b[i]);s.insert(c[i]);
if (s.size() == 3) ans += 2;
else if (s.size() == 2) ans += 1;
}
outl(ans);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
srand((unsigned)time(NULL));
fix(12);
solve();
}
| #include<bits/stdc++.h>
#define all(v) v.begin(),v.end()
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int a[5];
char ans[5];
string b;
cin>>b;
for(int i=0;i<4;i++){
a[i]=b[i]-'0';
ans[i]='+';
}
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
int sum=0;
for(int k=0;k<4;k++){
if(k==i && k!=0 || k==j && k!=0){
sum-=a[k];
}
else{
sum+=a[k];
}
}
if(sum==7){
ans[i]='-';
ans[j]='-';
cout<<a[0]<<ans[1]<<a[1]<<ans[2]<<a[2]<<ans[3]<<a[3]<<"="<<"7"<<endl;
return(0);
}
}
}
return(0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int sx,sy,tx,ty;
cin>>sx>>sy>>tx>>ty;
std::map<pair<int,int>, int> seen;
int x=sx,y=sy;
for (int i=0;i<2;i++) {
seen[pair(tx,ty)]=0;
seen[pair(x,y)]++;
while (1) {
if (x<tx&&seen[pair(x+1,y)]==0) {
cout<<"R";
seen[pair(x+1,y)]++;
x++;
} else if (y<=ty&&seen[pair(x,y+1)]==0) {
cout<<"U";
seen[pair(x,y+1)]++;
y++;
} else if (seen[pair(x-1,y)]==0) {
cout<<"L";
seen[pair(x-1,y)]++;
x--;
} else if (seen[pair(x,y-1)]==0) {
cout<<"D";
seen[pair(x,y-1)]++;
y--;
}
if (x==tx&&y==ty) {
break;
}
}
seen[pair(sx,sy)]=0;
//cout<<endl;
while (1) {
if (x>sx&&seen[pair(x-1,y)]==0) {
cout<<"L";
seen[pair(x-1,y)]++;
x--;
} else if (y>=sy&&seen[pair(x,y-1)]==0) {
cout<<"D";
seen[pair(x,y-1)]++;
y--;
} else if (seen[pair(x+1,y)]==0) {
cout<<"R";
seen[pair(x+1,y)]++;
x++;
} else if (seen[pair(x,y+1)]==0) {
cout<<"U";
seen[pair(x,y+1)]++;
y++;
}
if (x==sx&&y==sy) {
break;
}
}
//cout<<endl;
}
cout<<endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5500+5,M=1500,inf=0x3f3f3f3f,mod=1e9+7;
#define mst(a,b) memset(a,b,sizeof a)
#define lx x<<1
#define rx x<<1|1
#define reg register
#define PII pair<int,int>
#define fi first
#define se second
#define pb push_back
#define il inline
int sx,sy,ex,ey;
int main(){
cin>>sx>>sy>>ex>>ey;
for(int i=0;i<ey-sy;i++) putchar('U');
for(int i=0;i<ex-sx;i++) putchar('R');
for(int i=0;i<ey-sy;i++) putchar('D');
for(int i=0;i<ex-sx;i++) putchar('L');
putchar('L');
for(int i=0;i<=ey-sy;i++) putchar('U');
for(int i=0;i<=ex-sx;i++) putchar('R');
putchar('D');
putchar('R');
for(int i=0;i<=ey-sy;i++) putchar('D');
for(int i=0;i<=ex-sx;i++) putchar('L');
putchar('U');
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for (ll i=0; i<n; ++i)
#define all(c) begin(c),end(c)
/*
5の数
2の数
mapでいれとく
{2,5,小数の数｝
7.5=0,3,1
2.4=3,0,1
3-2=1>0だからOK
全部9桁として
9+4=13桁として扱う
2と5が18桁あればOK
10.000
20.000
10*10の組み合わせもとっちゃう。
2
200000*400はぎりぎりせーふ。50msくらい。
200000*1になりそう
*/
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
ll N; cin>>N;
vector<vector<ll>> DP(20, vector<ll>(20,0));
vector<pair<ll,ll>> Z(N,{0,0});
rep(i,N){
string S; cin>>S;
ll n=0, j=0, d=100;
while (S[j] && d-->0){
if (S[j] == '.'){
d=9;
j++;
continue;
}
n = n * 10 + (S[j++] - '0');
}
d = min(d, 9LL);
ll two=d, five=d;
while (n%2==0){
two++;
n/=2;
}
while (n%5==0){
five++;
n/=5;
}
two = min(two,18LL);
five = min(five,18LL);
DP[two][five]++;
Z[i] = {two,five};
}
//DPつくる
for(ll j=18; j>=0; j--) for(ll k=18; k>=0; k--)
DP[j][k] += DP[j][k+1];
for(ll j=18; j>=0; j--) for(ll k=18; k>=0; k--)
DP[k][j] += DP[k+1][j];
ll ans=0;
rep(i, N){
ll t=Z[i].first;
ll f=Z[i].second;
ans += DP[18-t][18-f];
if (t>=9 && f>=9)
ans--;
}
ans /= 2;
cout<<ans<<endl;
}
| #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 = 2e5 + 5;
int n;
int a[N];
int cnt[N];
int res;
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = n; i >= 1; --i) {
int Cnt = 0;
for (int j = i + i; j <= n; j += i) {
Cnt += cnt[j];
}
Cnt %= 2;
if (a[i] != Cnt) {
++res;
cnt[i] = 1;
}
}
cout << res << endl;
for (int i = 1; i <= n; ++i) {
if (cnt[i]) {
cout << i << ' ';
}
}
if (res)
cout << endl;
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
int main (){
int n = 0, m = 0;
while(true){
int ans = 0; //for answer
std::cin >> n >> m;
//exit when n = m = 0
if(n == 0 && m == 0){
break;
}
std::vector<int> price(n); //each vegetable price
//put price to vector
for(int i = 0; i < n; ++i){
std::cin >> price[i];
}
//descending sort
std::sort(price.begin(), price.end(), std::greater<int>());
//m'th vegetable don't add
for(int i = 0; i < n; ++i){
if((i+1) % m != 0){
ans += price[i];
}
}
std::cout << ans << std::endl;
}
return 0;
} | #include <cstdio>
#include <set>
#include <vector>
using namespace std;
inline int abs(int x) { return (x >= 0) ? x : - x; }
int main()
{
int n;
long d;
scanf("%d%ld", &n, &d);
vector<long> a(n);
for (int i = 0; i < n; i++)
scanf("%ld", &a[i]);
vector<long> b(n);
for (int i = 0; i < n; i++)
b[i] = a[i] + i * d;
set<pair<long, int>> pairs;
for (int i = 1; i < n; i++)
pairs.insert(make_pair(b[i], i));
long cost = 0;
int j = 0;
int k = 0;
while (!pairs.empty()) {
const int i = pairs.begin()->second;
cost += abs(i - j) * d + a[i] + a[j];
pairs.erase(pairs.begin());
for (k++; k < i; k++) {
cost += min(abs(i - k) * d + a[i] + a[k], abs(j - k) * d + a[j] + a[k]);
pairs.erase(make_pair(b[k], k));
}
if (a[i] < a[j] + abs(i - j) * d)
j = i;
}
printf("%ld\n", cost);
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <tuple>
using namespace std;
using int64 = long long;
using TP = tuple<int64,int,int>;
int main() {
int n;
cin >> n;
vector<TP> ab;
for (int i=0; i<n; i++) {
int a, b;
cin >> a >> b;
ab.emplace_back(a+b, a, b);
}
sort(ab.rbegin(), ab.rend());
int64 a = 0;
int64 b = 0;
for (int i=0; i<n; i++) {
if (i%2) b += get<2>(ab[i]);
else a += get<1>(ab[i]);
}
cout << (a-b) << endl;
} | #include <bits/stdc++.h>
using namespace std;
vector<vector<int>> way;
int64_t N, M;
vector<int> color;
bool dfs(int x, int col) {
color.at(x) = col;
for(int i = 0; i < way.at(x).size(); i++) {
if(color.at(way.at(x).at(i)) == col) {
return false;
}
if(color.at(way.at(x).at(i)) == -1) {
if(!dfs(way.at(x).at(i), 1 - col)) {
return false;
}
}
}
return true;
}
int main() {
cin >> N >> M;
way.assign(N, {});
color.assign(N, -1);
for(int64_t i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
way.at(a - 1).push_back(b - 1);
way.at(b - 1).push_back(a - 1);
}
if(!dfs(0, 0)) {
cout << N * (N - 1) / 2 - M << endl;
}
else {
int64_t total = 0;
for(int i = 0; i < N; i++) {
if(color.at(i) == 0) {
total++;
}
}
cout << total * (N - total) - M << endl;
}
} | 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 a, b; cin >> a >> b;
int n = 0;
while (1) {
if ((a-1) * n + 1 >= b) break;
n++;
}
cout << n << endl;
return 0;
} | // time-limit: 2000
// 23
#include <bits/stdc++.h>
using namespace std;
#define coutc "\033[48;5;196m\033[38;5;15m"
#define endc "\033[0m"
#define endl '\n'
#define M(_1, _2, _3, _4, NAME, ...) NAME
#define rep(...) \
M(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rep4(_, x, n, s) \
for (int _ = x; (s < 0) ? _ > n : _ < n; _ += s)
#define rep3(_, x, n) rep4(_, x, n, (x < n ? 1 : -1))
#define rep2(_, n) rep3(_, 0, n)
#define rep1(n) rep2(i, n)
#define fi first
#define se second
#define pb push_back
#define pii pair<int, int>
#define all(x) x.begin(), x.end()
#define len(x) int(x.size())
#define lli __int128_t
#define li long long int
#define ld long double
#ifdef DEBUG
// 3
ostream &operator<<(ostream &o, pair<auto, auto> p) {
return o << "(" << p.fi << ", " << p.se << ")";
}
// 4
ostream &operator<<(ostream &o, vector<auto> v) {
rep(i, len(v)) o << setw(7) << right << v[i];
return o << endc << endl << coutc;
}
// 4
ostream &operator<<(ostream &o, map<auto, auto> m) {
for (auto &kv : m) o << kv;
return o;
}
// 7
void debug(const auto &e, const auto &... r) {
cout << coutc << e;
((cout << " " << r), ..., (cout << endc << endl));
}
#else
#define debug(...)
#endif
int sign(li x) { return x < 0 ? -1 : x > 0; }
// a / b
li ceil(li a, li b) {
if (sign(a) == sign(b) && a % b) return a / b + 1;
else return a / b;
}
void _main(int tc) {
int a, b;
cin >> a >> b;
// b = a + (a - 1) * X
// X = (b - a) / (a - 1)
// is ceiling because we need to assure that with X pipes we complete "b - a" lines.
// we add one because after fullfilling "b - a" we still need to complete with "a" lines.
cout << ceil(b - a, a - 1) + 1 << endl;
}
// 7
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
_main(0), exit(0);
int tc;
cin >> tc;
rep(i, tc) _main(i + 1);
}
| 1 |
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <numeric>
#include <utility>
#include <vector>
using namespace std;
vector<int> ant;
int main() {
#ifdef HOME
freopen("agc01d.in", "r", stdin);
freopen("agc01d.out", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m, odd(0);
vector<int> v;
cin >> n >> m;
v.resize(m);
for (auto &i: v) {
cin >> i;
if (i % 2)
odd+= 1; }
if (odd > 2) {
cout << "Impossible\n";
return 0; }
ant.reserve(n);
partition(begin(v), end(v), [&](const int &x) { return x % 2; });
partition(begin(v) + 1, end(v), [&](const int &x) { return 1 - x % 2; });
ant.push_back(v[0] - 1);
n-= v[0] - 1;
for (int i = 1; i < m; ++i) {
ant.push_back(v[i]);
n-= v[i]; }
if (n > 0) {
if (v.back() == 1 || m != 1)
ant.back()+= n;
else
ant.push_back(n); }
ant.erase(remove(begin(ant), end(ant), 0), end(ant));
for (auto i: v)
cout << i << ' ';
cout << '\n' << ant.size() << '\n';
for (auto i: ant)
cout << i << ' ';
cout << endl;
return 0; }
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll = long long ;
using P = pair<int,int> ;
using pll = pair<long long,long long>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e17;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
int main(){
int n;
ll x;
cin >> n >> x;
vector<ll> a(n);
rep(i,n) cin >> a[i];
sort(a.begin(),a.end());
ll now = 0;
int ans = n;
rep(i,n){
now += a[i];
if(now > x){
ans = i;
break;
}
}
if(ans==n&&now!=x) cout << (n-1) << endl;
else cout << ans << endl;
return 0;
} | 0 |
#include<cstdio>
#include<iostream>
#include<map>
#include<set>
#include<vector>
#include<cstring>
#include<cassert>
#include<sstream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<limits>
#include<ctime>
#include<stack>
#include<bits/stdc++.h>
#include<string>
#include<stdlib.h>
#include<stdio.h>
typedef long long ll;
using namespace std;
const ll x=1000000007;
int mod(ll a){
return a%x;
}
int main(){
ll n;
cin>>n;
ll a[n],ans=0,mins=n+1;
for(int i=0;i<n;i++){
cin>>a[i];
if(a[i]<mins){
ans+=mins-a[i]-1;
mins=a[i];
}
}
cout<<n-ans;
} | /*
Push yourself, because no one else is going to do it for you.
*/
#include <bits/stdc++.h>
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define set_zero(a) memset(a,0,sizeof(a));
#define ll long long int
#define PI 2 * acos(0.0)
#define MAX 10000000000000000
#define in(a) scanf("%d",&a);
#define out(a) printf("%d",a);
#define INF 1000000
#define M 1000000007
using namespace std;
int main(){
fast_io
ll n;
cin>>n;
ll a[n];
for(ll i = 0;i<n;i++) cin>>a[i];
ll ans = a[0];
ll sum = 1;
for(ll i = 1;i<n;i++){
if(ans > a[i]){
sum++;
}
ans = min(a[i],ans);
}
cout<<sum<<endl;
return 0;
} | 1 |
const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No", "Yes"};
string YES[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k, n;
cin >> k >> n;
vi a(n);
forn(i, n) cin >> a[i];
int x = *max_element(all(a));
for (int bd = 0; bd <= 30000; bd++)
{
int nx = x - bd;
int ny = k - bd;
if (nx <= (ny + 1) / 2) cout << bd, exit(0);
}
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| #include <iostream>
#include <vector>
using namespace std;
int main(int argc, char* argv[]) {
int K, T;
cin >> K >> T;
vector<int> a(T);
int maximum = 0;
for (int i = 0; i < T; ++i) {
cin >> a[i];
maximum = max(maximum, a[i]);
}
cout << max(maximum - (K - maximum) - 1, 0) << endl;
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <tuple>
#include <numeric>
using namespace std; using ll = long long; using ld = long double; using pll = pair<ll, ll>;
using vl = vector<ll>; using vll = vector<vl>; using vpll = vector<pll>;
using vs = vector<string>; using tll = tuple<ll, ll, ll>; using vtll = vector<tll>;
const ld PI = 3.1415926535897932;
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define co(i) cout << i << endl;
#define co2(i,j) cout << i << " " << j << endl;
#define co3(i) cout << i << " ";
#define po(i) cout << i.first << " " << i.second << endl;
void in() {}
void debug_out() { cerr << endl; }
template<typename Head, typename... Tail>
void debug_out(Head h, Tail... t) {
cerr << " " << h;
if (sizeof...(t) > 0) cerr << " :";
debug_out(t...);
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> vec) {
for (size_t i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
ll ctoi(char c) {
switch (c) {
case '0': return 0; case '1': return 1; case '2': return 2;
case '3': return 3; case '4': return 4; case '5': return 5;
case '6': return 6; case '7': return 7; case '8': return 8;
case '9': return 9; default: return 0;
}
}
bool pairCompare(const pll firstElof, pll secondElof)
{
return firstElof.first > secondElof.first;
}
//**Snippetリスト**//
//rep, vin, all, iteLoop, bitSearch, bitList, nod, digitDP, treeDP//
//gcdlcm, isPrime, eratos, primeFactorize, Npow, combination, divisor, modinv, doubling//
//dfs, bfs, dijkstra, WarshallFloyd, BellmanFord, UnionFind, Kruskal, RMQ, LCA//
ll i, j, k, l; ll N, M, K, H, W, L, X, Y, Z, R, Q;
ll MOD = 1000000007, INF = 1LL << 60, ans = 0, z = 0, o = 1;
vll flag, D; vll path;
//***********//
class UnionFind {
public:
vl rank, par, siz;
UnionFind() {}
UnionFind(ll N) {
rank.resize(N, 0);
par.resize(N, 0);
siz.resize(N, 1);
init(N);
}
void init(ll N) {
for (ll i = 0; i < N; i++) {
par[i] = i;
rank[i] = 0;
}
}
ll find(ll x) {
if (par[x] == x) {
return x;
}
else {
return par[x] = find(par[x]);
}
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x != y) {
if (rank[x] < rank[y]) {
par[x] = y;
siz[y] += siz[x];
}
else {
par[y] = x;
siz[x] += siz[y];
if (rank[x] == rank[y]) rank[x]++;
}
}
}
bool issame(ll x, ll y) {
return find(x) == find(y);
}
ll size(ll x) {
return siz[find(x)];
}
};
int main() {
cin >> H >> W;
vs S(H);
for (i = 0; i < H; i++) cin >> S[i];
UnionFind UF(H * W);
for (i = 0; i < H; i++) {
for (j = 0; j < W-1; j++) if (S[i][j] != S[i][j + 1]) UF.unite(i * W + j, i * W + j + 1);
}
for (j = 0; j < W; j++) {
for (i = 0; i < H - 1; i++) if (S[i][j] != S[i+1][j]) UF.unite(i * W + j, i * W + j + W);
}
map<ll, pll> P;
for (i = 0; i < H; i++) {
for (j = 0; j < W; j++) {
if (S[i][j] == '.') P[UF.find(i * W + j)].first++;
else P[UF.find(i * W + j)].second++;
}
}
for (auto x : P) ans += x.second.first * x.second.second;
co(ans);
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
//#define MOD 1000000007
const int INF = 1LL<<30;
char fi[410][410];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int h,w;
int vis[410][410];
int main() {
cin>>h>>w;
rep(i,h){
rep(j,w){
cin>>fi[i][j];
}
}
ll ans=0;
rep(i,h){
rep(j,w){
if(vis[i][j]) continue;
vis[i][j]=true;
vector<ll> num(2,0);
queue<pair<int,int>> que;
que.push({i,j});
while (!que.empty())
{
auto p=que.front();
que.pop();
int x=p.first,y=p.second;
num[fi[x][y]=='#']++;
rep(k,4){
int nx=x+dx[k];
int ny=y+dy[k];
if(nx>=0 && nx<h && ny>=0 && ny<w && !vis[nx][ny] && fi[nx][ny]!=fi[x][y]){
que.push({nx,ny});
vis[nx][ny]=true;
}
}
}
ans+=num[0]*num[1];
}
}
cout<<ans<<endl;
} | 1 |
//#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define trav(x,a) for (const auto& x: a)
#define sz(x) (int)(x).size()
#define mem(a,v) memset((a), (v), sizeof (a))
#define enl printf("\n")
#define case(t) printf("Case #%d: ", (t))
#define ni(n) scanf("%d", &(n))
#define nl(n) scanf("%lld", &(n))
#define nai(a, n) for (int _i = 0; _i < (n); _i++) ni(a[_i])
#define nal(a, n) for (int _i = 0; _i < (n); _i++) nl(a[_i])
#define pri(n) printf("%d\n", (n))
#define prl(n) printf("%lld\n", (n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define vii vector<pii>
#define vll vector<pll>
#define vi vector<int>
#define vl vector<long long>
#define pb push_back
#define mp make_pair
#define st first
#define nd second
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef cc_hash_table<int,int,hash<int>> ht;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> oset;
const double pi = acos(-1);
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
const int N = 1e6 + 5;
const double eps = 1e-9;
vi adj[N];
int dp[N], par[N];
int main() {
int n, m; scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v; scanf("%d %d", &u, &v);
adj[u].pb(v);
}
int len = inf, idx = -1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
dp[j] = inf;
deque<int> pq; pq.pb(i);
dp[i] = 0;
int mn = inf;
while (sz(pq)) {
int u = pq.front(); pq.pop_front();
trav(v, adj[u]) {
if (v == i)
mn = min(mn, dp[u]+1);
if (dp[v] > dp[u] + 1) {
dp[v] = dp[u] + 1;
pq.pb(v);
}
}
}
if (mn < len) {
len = mn, idx = i;
}
}
if (idx < 0)
return !printf("-1\n");
for (int j = 1; j <= n; j++)
dp[j] = inf;
deque<int> pq; pq.pb(idx);
dp[idx] = 0;
int c = 0;
while (sz(pq)) {
int u = pq.front(); pq.pop_front();
c++;
int d = dp[u];
if (c == 1)
dp[u] = inf;
trav(v, adj[u]) {
if (dp[v] > d + 1) {
dp[v] = d + 1;
par[v] = u;
pq.pb(v);
}
}
}
vi ans;
int u = idx;
do {
ans.pb(u);
u = par[u];
} while (u != idx);
printf("%d\n", sz(ans));
trav(v, ans) printf("%d\n", v);
return 0;
}
| #include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
#define chmin(a,b) a=min(a,b)
#define chmax(a,b) a=max(a,b)
#define all(x) x.begin(),x.end()
#define rep(i,n) for(int i=0;i<n;i++)
#define mod 1000000007
#define mad(a,b) a=(a+b)%mod
#define N 100010
vector<ll> g[N];
ll col[N];
ll cnt;
bool nibu;
void dfs(ll x,ll c){
if(~col[x]){
if(c!=col[x])nibu=0;
return;
}
cnt++;
col[x]=c;
for(auto y:g[x])dfs(y,c^1);
}
ll n,m;
int main(){
cin>>n>>m;
rep(i,m){
ll a,b; cin>>a>>b;
a--,b--;
g[a].push_back(b);
g[b].push_back(a);
}
rep(i,n)col[i]=-1;
ll nonone=0;
ll sei=0,nisei=0;
rep(i,n)if(col[i]==-1){
cnt=0;
nibu=1;
dfs(i,0);
if(cnt>1){
nonone+=cnt;
sei++;
if(nibu)nisei++;
}
}
ll ans=n*n-nonone*nonone;
ans+=sei*sei+nisei*nisei;
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<string.h>
using namespace std;
#define pb push_back
#define all(v) v. begin(),v. end()
#define rep(i,n,v) for(i=n;i<v;i++)
#define per(i,n,v) for(i=n;i>v;i--)
#define ff first
#define ss second
#define pp pair<ll,ll>
#define eps 1e-6
#define ll long long
#define endl '\n'
void solve()
{
ll n, a,m=0,b=1, k=0, i, j,l=2e9+7;
string s, r, y;
cin>>n>>a>>b;
k=min(n+a,min(n+b,a+b));
cout<<k;
/*if(n<a) cout<<0;
else cout<<10;*/
}
int main()
{
ios_base::sync_with_stdio(false);
cin. tie(0);cout. tie(0);
ll t=1;
// cin>>t;
while(t--)
{
solve();
}
return 0;
} | #include<iostream>
using namespace std;
int main()
{
// 整数の入力
int N, X, T;
cin >> N >> X >> T;
// スペース区切りの整数の入力
int x = N / X * T;
if ( N % X > 0 ){
x += T;
}
cout << x << endl;
} | 0 |
#include<bits/stdc++.h>
typedef long double ld;
using namespace std;
int main(void){
int n; cin>>n;
vector<pair<ld,ld>> ab(n);
for(auto& i:ab) cin>>i.first>>i.second;
ld res=0;
for(int i=0; i<n; ++i) for(int j=i+1; j<n; ++j){
ld x=ab[i].first-ab[j].first;
ld y=ab[i].second-ab[j].second;
res+=sqrtl(x*x+y*y)*2;
}
printf("%.10llf",res/n);
return 0;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi=vector<int>;
double dist(int x1,int y1, int x2, int y2){
return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
}
int main() {
int N; cin>>N;
vi x(N),y(N);
for (int i = 0; i < N; i++){
cin>>x[i]>>y[i];
}
vi perm(N);
for (int i = 0; i < N; i++){
perm[i]=i;
}
double sum=0;
do{
for (int i = 0; i < N-1; i++){
sum+=dist(x[perm[i]],y[perm[i]],x[perm[i+1]],y[perm[i+1]]);
}
}while(next_permutation(perm.begin(),perm.end()));
int fact=1;
for (int i = 1; i <= N; i++){
fact*=i;
}
printf("%.7f\n",sum/(double)fact);
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> a(n);
vector<int> b(n);
vector<int> x(n);
int64_t sb=0;
for(int i=0;i<n;i++){
cin>>a.at(i)>>b.at(i);
x.at(i)=a.at(i)+b.at(i);
sb+=b.at(i);
}
sort(x.begin(),x.end(),greater<int>());
int64_t sx=0;
for(int i=0;i<n;i+=2)
sx+=x.at(i);
cout<<sx-sb<<endl;
} |
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
typedef unsigned long long ULLONG;
typedef long long LLONG;
static const LLONG MOD_NUM = 1000000007;
template<class _T> static void getint(_T& a) {
std::cin >> a;
}
template<class _T> static void getint(_T& a, _T& b) {
std::cin >> a >> b;
}
template<class _T> static void getint(_T& a, _T& b, _T& c) {
std::cin >> a >> b >> c;
}
template <class _T> static _T tp_abs(_T a) {
if (a < (_T)0) {
a *= (_T)-1;
}
return a;
}
static void exec();
int main()
{
exec();
fflush(stdout);
return 0;
}
static void exec()
{
int N;
getint(N);
std::vector<std::pair<LLONG, LLONG>> plates(N);
for (int i = 0; i < N; i++) {
getint(plates[i].first, plates[i].second);
}
std::sort(plates.begin(), plates.end(),
[](const std::pair<LLONG, LLONG>& a, const std::pair<LLONG, LLONG>& b) {
return (a.first + a.second) > (b.first + b.second);
});
bool tkhs = true;
std::vector<std::pair<LLONG, LLONG>> tk, ao;
for (int i = 0; i < N; i++) {
if (tkhs) {
tk.push_back(plates[i]);
tkhs = false;
}
else {
ao.push_back(plates[i]);
tkhs = true;
}
}
LLONG tkSum = 0;
for (auto it = tk.begin(); it != tk.end(); it++) {
tkSum += it->first;
}
LLONG aoSum = 0;
for (auto it = ao.begin(); it != ao.end(); it++) {
aoSum += it->second;
}
printf("%lld\n", tkSum - aoSum);
}
| 1 |
#include<bits/stdc++.h>
#define endl '\n'
#define INF (1 << 21)
const int MOD = 1000000009;
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
int ice[10];
int c;
cin >> n;
while(n != 0){
memset(ice, 0, sizeof(ice));
for(int i = 0;i < n;i++){
cin >> c;
ice[c]++;
}
for(int i = 0;i <= 9;i++){
if(ice[i] == 0){
cout << "-" << endl;
}else{
for(int j = 0;j < ice[i];j++){
cout << "*";
}
cout << endl;
}
}
cin >> n;
}
return 0;
}
| #include<iostream>
using namespace std;
int main(void)
{
int n,i,j=1,max,a[3];
cin>>n;
for(i=0;i<n;i++) cin>>a[i];
if(n==2){
if(a[1]<=a[0]) max=a[0];
else max=a[1];
while(1){
if(j==max) break;
if(a[0]%j==0 && a[1]%j==0){
cout<<j<<endl;
}
j+=1;
}
}
if(n==3){
if(a[0]>=a[1] && a[0]>=a[2]) max=a[0];
else if(a[1]>=a[0] && a[1]>=a[2]) max=a[1];
else max=a[2];
while(1){
if(j==max) break;
if(a[0]%j==0 && a[1]%j==0 && a[2]%j==0){
cout<<j<<endl;
}
j+=1;
}
}
return 0;
}
| 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(ll i=(a);i<(b);++i)
#define rep(i,n) for(ll i=0;i<(n);++i)
#define REPR(i,n) for(ll i=n;i>=0;i--)
#define FOREACH(x,a) for(auto& (x) : (a) )
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template<typename T>
void print(const vector<T> &x) {
int n = x.size();
rep(i,n) {
cout << x[i];
if (i!=n-1) cout<<" ";
else cout << endl;
}
}
template<typename T>
void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i,n) {
rep(j,x[i].size()) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
template<typename T>
void print(const vector<T> &x, int n) {
rep(i,n) {
cout << x[i];
if (i!=n-1) cout<<" ";
else cout << endl;
}
}
template<typename T>
void print(const vector<vector<T>> &x, int n, int m) {
rep(i,n) {
rep(j,m) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
void input_init() {
cin.tie(0); ios::sync_with_stdio(false);
}
int main(int argc, char const *argv[]) {
int n; cin>>n;
vector<P> a(n);
rep(i,n) {
string s; cin>>s;
int sum = 0;
int mini = INF;
for (auto &&e: s) {
if (e == '(') sum++;
else sum--;
chmin(mini, sum);
}
a[i].first = mini;
a[i].second = sum;
}
auto print = [&]() {
for (auto &&e: a) cout << e.first << ", " << e.second << '\n';
};
vector<P> ans;
sort(a.begin(), a.end(), greater<>());
for (auto &&e: a) {
if (e.second >= 0) {
ans.push_back(e);
}
}
sort(a.begin(), a.end(), [](const P &l, const P &r) {
return l.second-l.first > r.second-r.first;
});
for (auto&&e: a) {
if (e.second < 0) {
ans.push_back(e);
}
}
P c;
bool ok = true;
for (auto &&e: ans) {
if (c.second+e.first < 0) ok = false;
c.second += e.second;
}
if (c.second != 0) ok = false;
if (ok) {
cout << "Yes" << '\n';
}
else {
cout << "No" << '\n';
}
return 0;
}
| #include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
#include <iomanip>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> P;
const ll MOD=1000000007;
const ll MAX_N=500010;
const ll INF=999999999999;
int main(){
int n;
cin>>n;
vector<int> a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
vector<int> b(n,0);
int ans=0;
for(int i=n-1;i>=0;i--){
int now=i+1;
int widt=now;
int num=0;
for(;now<=n;now+=widt){
num+=b[now-1];
}
if(num%2==a[i]){
b[i]=0;
}else{
b[i]=1;
ans++;
}
}
cout<<ans<<endl;
for(int i=0;i<b.size();i++){
if(b[i]) cout<<i+1<<" ";
}
cout<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int D, G;
cin >> D >> G;
vector < int >p(D), c(D);
for (int i = 0; i < D; i++) {
cin >> p[i] >> c[i];
}
int ans = INT_MAX;
for (int bits = 0; bits < (1 << D); bits++) {
int score = 0;
int num = 0;
int resultMax = -1;
for (int i = 0; i < D; i++) {
if (bits >> i & 1) {
score += 100 * (1 + i) * p[i] + c[i];
num += p[i];
} else {
resultMax = i;
}
}
if (score < G) {
int s1 = 100 * (resultMax + 1);
int need = (G - score + s1 - 1) / s1;
if (need >= p[resultMax]) {
continue;
}
num += need;
}
ans = min(ans, num);
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
template<class T> void chmax(T& x, T y){if(x < y) x = y;}
template<class T> void chmin(T& x, T y){if(x > y) x = y;}
int N, M;
int A[310][310];
int cnt[310];
bool hold[310];
int idx[310];
int solve(){
bool flag = false;
for(int i = 1; i <= M; i++){
if(hold[i]) flag = true;
}
if(!flag) return 1 << 30;
for(int i = 1; i <= N; i++){
if(hold[A[i][idx[i]]]) continue;
for(int& j = idx[i]; j <= M; j++){
if(hold[A[i][j]]){
cnt[A[i][j]]++;
break;
}
}
}
int mx = 0;
for(int i = 1; i <= M; i++){
chmax(mx, cnt[i]);
}
set<int> h;
for(int i = 1; i <= M; i++){
if(cnt[i] == mx){
h.insert(i);
hold[i] = false;
cnt[i] = 0;
}
}
return min(solve(), mx);
}
int main(){
cin >> N >> M;
for(int i = 1; i <= N; i++){
for(int j = 1; j <= M; j++){
cin >> A[i][j];
}
}
for(int i = 1; i <= M; i++){
hold[i] = true;
}
cout << solve() << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr int Inf = 1000000001;
constexpr ll INF= 1e18;
constexpr ll MOD = 1000000007;
const double PI = 3.1415926535897;
typedef pair<int,int> P;
int main() {
int N;
cin >> N;
string A,B,C;
cin >> A >> B >> C;
int ret = 0;
for(int i = 0;i < N;i++) {
if(A.at(i) == B.at(i) && B.at(i) == C.at(i)) {
ret = ret;
}
else if(A.at(i) == B.at(i)) {
ret++;
}
else if(B.at(i) == C.at(i)) {
ret++;
}
else if(A.at(i) == C.at(i)) {
ret++;
}
else {
ret += 2;
}
}
cout << ret << endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
int main() {
ll n;
cin >> n;
vector<string> s(3);
for(ll i=0;i<3;i++) {
cin >> s[i];
}
ll ans=0;
for(ll i=0;i<n;i++) {
set<char> ss;
for(ll j=0;j<3;j++) {
ss.insert(s[j][i]);
}
ans+=ss.size()-1;
}
cout << ans << endl;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
typedef pair<int, bool> Link;
typedef vector<vector<Link> > Graph;
int main () {
int V, E;
cin >> V >> E;
Graph g(V, vector<Link>(V));
// Set identity to 0
for(int i=0; i<V; i++)
g[i][i] = make_pair(0, true);
// Set known edges
for(int i=0; i<E; i++) {
int s, t, d;
cin >> s >> t >> d;
g[s][t] = make_pair(d, true);
}
// Run Floyd-Warshall algorithm
for(int k=0; k<V; k++)
for(int i=0; i<V; i++)
for(int j=0; j<V; j++)
if (
(g[i][k].second && g[k][j].second) &&
(!g[i][j].second || g[i][j].first > g[i][k].first + g[k][j].first))
g[i][j] = make_pair(g[i][k].first + g[k][j].first, true);
// Check if any cycle
for(int i=0; i<V; i++)
if (g[i][i].first < 0) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
// Print output
for(int i=0; i<V; i++) {
for(int j=0; j<V; j++)
if (g[i][j].second)
cout << (j ? " " : "") << g[i][j].first;
else
cout << (j ? " " : "") << "INF";
cout << endl;
}
}
| #include<bits/stdc++.h>
using namespace std;
int N,M;
int main()
{
while(true){
scanf("%d%d",&N,&M);
if(N==0&&M==0)return 0;
int cost[200][200];
int time[200][200];
int minc[200][200];
int mint[200][200];
for(int i=0;i<M;i++){
for(int j=0;j<M;j++){
cost[i][j]=1<<25;
time[i][j]=1<<25;
minc[i][j]=1<<25;
mint[i][j]=1<<25;
if(i==j){
cost[i][j]=0;
time[i][j]=0;
minc[i][j]=0;
mint[i][j]=0;
}
}
}
int A,B,co,ti;
for(int i=0;i<N;i++){
scanf("%d%d%d%d",&A,&B,&co,&ti);A--;B--;
cost[A][B]=co;cost[B][A]=co;
time[A][B]=ti;time[B][A]=ti;
}
for(int i=0;i<M;i++){
for(int j=0;j<M;j++){
for(int k=0;k<M;k++){
cost[j][k]=min(cost[j][k],cost[j][i]+cost[i][k]);
time[j][k]=min(time[j][k],time[j][i]+time[i][k]);
}
}
}
int K;
scanf("%d",&K);
for(int i=0;i<K;i++){
int P,Q,R;
scanf("%d%d%d",&P,&Q,&R);P--;Q--;
if(R==0)printf("%d\n",cost[P][Q]);
else printf("%d\n",time[P][Q]);
}
}
} | 0 |
#include<iostream>
#include<string>
#include<vector>
#include<cstdio>
#include<sstream>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
int main(){
int n, dp[50];
while(cin>>n,n!=0){
fill(dp,dp+50,0);
dp[0]=0,dp[1]=1,dp[2]=1,dp[3]=2;
for(int i=3;i<=n+1;i++)dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
int ans=dp[n+1];
ans/=3650;
if(dp[n]%3650!=0)ans++;
cout<<ans<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define x first
#define y second
typedef pair<int,int> pii;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
template <typename T> void chkmax(T &x,T y){x<y?x=y:T();}
template <typename T> void chkmin(T &x,T y){x>y?x=y:T();}
template <typename T> bool readint(T &x)
{
x=0;int f=1;char c;
for(c=getchar();!isdigit(c);c=getchar())if(c=='-')f=-1;
for(;isdigit(c);c=getchar())x=x*10+c-'0';
x*=f;
return c=='.';
}
const int MAXN=200005;
int n;
ll a[MAXN];
pii b[MAXN];
int cnt[100][100];
int main()
{
#ifdef LOCAL
freopen("code.in","r",stdin);
// freopen("code.out","w",stdout);
#endif
readint(n);
int s=0;
for(int i=1;i<=n;++i)
{
ldb d;
scanf("%Lf",&d);
a[i]=d*1000000000+0.5;
while(a[i]%2==0)a[i]>>=1,++b[i].x;
while(a[i]%5==0)a[i]/=5,++b[i].y;
++cnt[b[i].x][b[i].y];
if(b[i].x>=9 && b[i].y>=9)++s;
}
sort(b+1,b+n+1);
ll ans=0;
for(int i=0;i<=55;++i)
for(int j=0;j<=55;++j)
for(int x=0;x<=55;++x)
for(int y=0;y<=55;++y)
if(i+x>=18 && j+y>=18)
ans+=1ll*cnt[i][j]*cnt[x][y];
printf("%lld\n",(ans-s)/2);
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int a,b,l=100,s=0;
for(int i=0;i<4;i++){
cin>>a;
s+=a;
l=min(a,l);
}
cin>>a>>b;
cout<<s-l+max(a,b)<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
vector<int> SubjectsInfo;
int main() {
int score;
for (int i = 0; i < 6; ++i) {
cin >> score;
SubjectsInfo.push_back(score);
}
sort(SubjectsInfo.begin(), SubjectsInfo.begin() + 4);
cout << SubjectsInfo[1] + SubjectsInfo[2] + SubjectsInfo[3] + max(SubjectsInfo[4], SubjectsInfo[5]) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
string S; cin>>S;
if(S.size()==2)
cout<<S<<endl;
else
cout<<S.at(2)<<S.at(1)<<S.at(0)<<endl;
} | const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > G;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Ans[2] = {"No", "Yes"};
string ANS[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
int t;
void dfs(int v, int p, G &graph, vi &in, vi &up)
{
up[v] = in[v] = t;
t++;
for (auto u : graph[v])
{
if (u == p) continue;
if (in[u] == 0)
{
dfs(u, v, graph, in, up);
}
up[v] = min(up[v], up[u]);
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s.size() == 3) reverse(all(s));
cout << s;
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| 1 |
#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<iostream>
using namespace std;
int main(){
int x;
cin>>x;
int temp=x;
int sum=0;
while(temp!=0)
{
sum+=temp%10;
temp/=10;
}
if(x%sum==0)
{
cout<<"Yes";
}
else
cout<<"No";
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define all(z) (z).begin(),(z).end()
#define MOD 1000000007
#define FAST ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll isprime(ll n)
{
for(int i=2;i<n;i++)
if(n%i==0)
return 0;
return 1;
}
int main()
{
FAST;
long double d,t,s;
cin>>d>>t>>s;
if(d/s<=t)cout<<"Yes";
else cout<<"No";
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int d, t, s;
cin >> d >> t >> s;
string ans = "Yes";
if (s * t < d) ans = "No";
cout << ans << endl;
} | 1 |
#include<iostream>
#include<math.h>
using namespace std;
class Xcubic{
public:
int cal(int x){
int res=(int)pow(x,3);
return res;
}
};
int main(){
int x;
cin>>x;
Xcubic xcubic;
cout<<xcubic.cal(x)<<endl;
return 0;
} | #include<iostream>
#include<iomanip>
using namespace std;
int main(void){
int x;
cin >> x;
cout << x*x*x <<"\n";
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string S;
cin >> S;
if(S == "SSS") cout << "0" << endl;
else if(S == "RRR") cout << "3" << endl;
else if(S == "SRR" || S == "RRS") cout << "2" << endl;
else cout << "1" << endl;
} | #include<iostream>
#include<cstring>
using namespace std;
char str[1010];
int main(){
scanf("%s",str);
int len=strlen(str);
int res=0;
for(int i=0;i<len;++i){
int cnt=0;
while(i<len&&str[i]=='R'){
cnt++;
i++;
}
res=max(cnt,res);
}
cout<<res<<endl;
return 0;
} | 1 |
#include<iostream>
#include<vector>
#include<string>
using namespace std;
int main() {
while (1) {
int a;
cin >> a;
if (a == 0)break;
for (int b = 0; b < a; b++) {
int c, d, e;
cin >> c >> d >> e;
if (c == 100 || d == 100 || e == 100)cout << "A" << endl;
else if (c+d>179)cout << "A" << endl;
else if(c+d+e>239)cout << "A" << endl;
else if(c+d+e>209)cout << "B" << endl;
else if((c+d+e>149)&&(c>79||d>79))cout << "B" << endl;
else cout << "C" << endl;
}
}
} | #include <iostream>
#include <algorithm>
using namespace std;
int mp[101][101];
bool flg[101] ={};
int n,q;
int dis[101];
int sssp(int s,int g) {
for(int i=1;i<=n;i++) dis[i] = 1000000000,flg[i] = 0;
//flg[s] = 1;
dis[s] = 0;
int ima;
while(1) {
int mindis = 1000000000;
for(int i=1;i<=n;i++)
if(mindis > dis[i] && flg[i] == 0) {
ima = i;
mindis = dis[i];
}
if(mindis == 1000000000) return -1;
flg[ima] = 1;
if(ima == g) return dis[ima];
for(int i=1;i<=n;i++)
if(dis[i] >dis[ima] + mp[ima][i] && mp[ima][i] != -1)
dis[i] = dis[ima]+mp[ima][i];
}
return dis[g];
}
int main() {
while(1) {
cin >> n >> q;
if(n == 0 && q == 0) break;
for(int i=0;i<=n;i++){
// dis[i] = 1000000000;
//flg[i] = 0;
for(int j=0;j<=n;j++)
mp[i][j] = -1;
}
bool sta;
int s,g,c;
for(int i=0;i<q;i++) {
cin >> sta;
if(sta == 0) {
cin >> s >> g;
//for(int i=1;i<=n;i++) if(mp[s][i] !=-1)dis[i] = mp[s][i];
int ans = sssp(s,g);
cout << ans<< endl;
}
else {
cin >> s >> g >> c;
if(mp[s][g] != -1) {
mp[s][g] = min(c ,mp[s][g]);
mp[g][s] = min( mp[g][s] ,c);
}
else {
mp[s][g] = c;
mp[g][s] = c;
}
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
double const PI = 3.1415926535897932384626433;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if (e - a <= k) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int A, B, C, D, E, K;
vector<int> a;
int main() {
cin >> A >> B >> C >> D >> E >> K;
a.push_back(A); a.push_back(B); a.push_back(C); a.push_back(D); a.push_back(E);
bool istrue = true;
for (int i=0; i<a.size(); i++) {
for (int j=i+1; j<a.size(); j++) {
if (abs(a[i] - a[j]) > K) { istrue = false; break; }
}
}
istrue ? cout << "Yay!\n" : cout << ":(\n";
return 0;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
class Dice{
public:
int n1,n2,n3,n4,n5,n6;
void East(){
int t = n1;
n1 = n4;
n4 = n6;
n6 = n3;
n3 = t;
}
void West(){
int t = n1;
n1 = n3;
n3 = n6;
n6 = n4;
n4 = t;
}
void South(){
int t=n1;
n1 = n5;
n5 = n6;
n6 = n2;
n2 = t;
}
void North(){
int t=n1;
n1 = n2;
n2 = n6;
n6 = n5;
n5 = t;
}
};
int main() {
Dice dice;
int n1, n2, n3, n4, n5, n6;
char ch;
cin >> n1 >> n2 >> n3 >> n4 >> n5 >> n6;
dice.n1 = n1;
dice.n2 = n2;
dice.n3 = n3;
dice.n4 = n4;
dice.n5 = n5;
dice.n6 = n6;
while(cin >> ch){
if(ch=='E'){
dice.East();
}
else if(ch=='W'){
dice.West();
}
else if(ch=='S'){
dice.South();
}
else if(ch=='N'){
dice.North();
}
}
cout << dice.n1 << endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <string>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
string str;
int ans;
class dice{
public:
int n[6];
void E(){
int t = n[0];
n[0] = n[3];
n[3] = n[5];
n[5] = n[2];
n[2] = t;
}
void W(){
int t = n[0];
n[0] = n[2];
n[2] = n[5];
n[5] = n[3];
n[3] = t;
}
void S(){
int t = n[0];
n[0] = n[4];
n[4] = n[5];
n[5] = n[1];
n[1] = t;
}
void N(){
int t = n[0];
n[0] = n[1];
n[1] = n[5];
n[5] = n[4];
n[4] = t;
}
};
int main(){
dice d;
rep(i, 6) cin >> d.n[i];
cin >> str;
ans = d.n[0];
rep(i, str.length()){
switch (str[i])
{
case 'E':
d.E();
break;
case 'W':
d.W();
break;
case 'S':
d.S();
break;
case 'N':
d.N();
break;
default:
break;
}
}
cout << d.n[0] << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
signed main()
{
double x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << fixed << setprecision(10) << sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) << endl;
return (0);
} | #include<stdio.h>
int main()
{
int x,y,z;
scanf("%d %d %d",&x,&y,&z);
if (x>9 || x<1 || y>9 || y<1 || z>9 || z<1)
{
printf("Error!");
}
else if( x == y && y == z && x == z){
printf("No");
}
else if (x == z || x == y || y == z){
printf("Yes");
}
else if (x>y || z>x || y>z){
printf("No");
}
} | 0 |
#include<iostream>
using namespace std;
const int INF = 2000000;
struct LineTable{
int cost;
int times;
LineTable(){
cost = INF;
times = INF;
}
};
int main(){
int n,m;
while(1){
cin >> n >> m;
if(n==0&&m==0){
break;
}
LineTable table[m][m];
for(int i=0;i<m;i++){
table[i][i].cost = 0;
table[i][i].times = 0;
}
for(int i=0;i<n;i++){
int a,b,cost,times;
cin >> a >> b >> cost >> times;
table[a-1][b-1].cost = cost;
table[a-1][b-1].times = times;
table[b-1][a-1].cost = cost;
table[b-1][a-1].times = times;
}
for(int k=0;k<m;k++){
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
if(table[i][j].cost > table[i][k].cost + table[k][j].cost){
table[i][j].cost = table[i][k].cost + table[k][j].cost;
}
}
}
}
for(int k=0;k<m;k++){
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
if(table[i][j].times > table[i][k].times + table[k][j].times){
table[i][j].times = table[i][k].times + table[k][j].times;
}
}
}
}
/* for(int k=m-1;k>=0;k--){
for(int i=m-1;i>=0;i--){
for(int j=m-1;j>=0;j--){
if(table[i][j].cost > table[i][k].cost + table[k][j].cost){
table[i][j].cost = table[i][k].cost + table[k][j].cost;
}
}
}
}
for(int k=m-1;k>=0;k--){
for(int i=m-1;i>=0;i--){
for(int j=m-1;j>=0;j--){
if(table[i][j].times > table[i][k].times + table[k][j].times){
table[i][j].times = table[i][k].times + table[k][j].times;
}
}
}
}*/
int k,p,q,r;
cin >> k;
/*cin >> p >> q >> r;
if(r==0){
cout << table[p-1][q-1].cost;
}
else{
cout << table[p-1][q-1].times;
}
for(int i=1;i<k;i++){
cin >> p >> q >> r;
if(r==0){
cout << ' ' <<table[p-1][q-1].cost;
}
else{
cout << ' ' <<table[p-1][q-1].times;
}
}
cout << endl;*/
for(int i=0;i<k;i++){
cin >> p >> q >> r;
if(r==0){
cout << table[p-1][q-1].cost << endl;;
}
else{
cout << table[p-1][q-1].times << endl;
}
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
struct Graph{
Graph(int n):E(n),d(n){}
vector<vector<tuple<int,int,int>>>E;
vector<int>d;
void add_edge(int a,int b,int c,int d){
E[a].push_back(make_tuple(b,c,d));
}
void dijkstra(int s,int f){
priority_queue<P,vector<P>,greater<P>>q;
fill(d.begin(),d.end(),1e9);
q.push({d[s]=0,s});
while(q.size()){
auto p=q.top();q.pop();
if(p.first>d[p.second])continue;
for(auto& a:E[p.second]){
int x=get<0>(a),y=get<1>(a)+p.first;
if(f)y=get<2>(a)+p.first;
if(y<d[x])d[x]=y,q.push({y,x});
}
}
}
};
main(){
int n,m,a,b,c,d,k;
while(cin>>n>>m,n){
Graph E(m);
for(int i=0;i++<n;E.add_edge(--a,--b,c,d),E.add_edge(b,a,c,d))cin>>a>>b>>c>>d;
cin>>k;
for(int i=0;i++<k;cout<<E.d[--b]<<endl){
cin>>a>>b>>c;
E.dijkstra(--a,c);
}
}
} | 1 |
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll a;
ll b;
ll c;
cin>>a;
cin>>b;
cin>>c;
if((a==b)&&(b==c))
{
cout<<"No"<<"\n";
}
else if((a!=b)&&(b!=c)&&(c!=a))
{
cout<<"No"<<"\n";
}
else
{
cout<<"Yes"<<"\n";
}
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <ctype.h>
#include <math.h>
#include <stack>
#include <string>
#include <string.h>
using namespace std;
double PI = 3.1415926535897932;
long mod = 1000000007;
const long INF = 1e9 + 1;
int main() {
int a[3];
cin >> a[0] >> a[1] >> a[2];
sort(a,a+3);
if(a[0] == a[1] & a[1] == a[2]) cout << "No" << endl;
else if(a[0] != a[1] & a[1] != a[2]) cout << "No" << endl;
else if(a[0] == a[1] & a[1] != a[2]) cout << "Yes" << endl;
else if(a[0] != a[1] & a[1] == a[2]) cout << "Yes" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define SZ(X) ((int)(X).size())
#define endl "\n";
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n,a[9]={111,222,333,444,555,666,777,888,999};
cin>>n;
for(int i=0;i<9;i++){
if(n<=a[i]) {
cout<<a[i]<<endl;
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
cout << ((n + 110) / 111) * 111 << endl;
}
| 1 |
#include<bits/stdc++.h>
#define int long long
#define for0(i, n) for(int i = 0; i < (n); i++)
#define mp make_pair
using namespace std;
int t, n, q, l = 0, r = 123456, x = 2147483647, q1;
pair<int, int>t1[123456], t2[12345], t3[1234], t4[123], t5[12];
void f1() {
r++;
while (l < r) {
if (l % 10000 == 0 && l + 10000 <= r) {
t5[l / 10000] = mp(t, x);
l += 10000;
}
else if (l % 1000 == 0 && l + 1000 <= r) {
t4[l / 1000] = mp(t, x);
l += 1000;
}
else if (l % 100 == 0 && l + 100 <= r) {
t3[l / 100] = mp(t, x);
l += 100;
}
else if (l % 10 == 0 && l + 10 <= r) {
t2[l / 10] = mp(t, x);
l += 10;
}
else {
t1[l] = mp(t, x); l++;
}
}
}
int f2(int i) {
int t = t1[i].first, x = t1[i].second;
i /= 10;
if (t < t2[i].first) {
t = t2[i].first; x = t2[i].second;
}
i /= 10;
if (t < t3[i].first) {
t = t3[i].first; x = t3[i].second;
}
i /= 10;
if (t < t4[i].first) {
t = t4[i].first; x = t4[i].second;
}
i /= 10;
if (t < t5[i].first) {
t = t5[i].first; x = t5[i].second;
}
return x;
}
signed main() {
cin >> n >> q;
for0(i, n)t1[i] = mp(0, x);
for (t = 1; t <= q; t++) {
cin >> q1;
if (q1) {
int i; cin >> i; cout << f2(i) << endl;
}
else {
cin >> l >> r >> x; f1();
}
}
}
| #include <bits/stdc++.h>
using namespace std;
const int INF=INT_MAX;
struct lst
{
private:
int n;
vector<int> node;
vector<int> lazy;
vector<bool> lflg;
public:
lst(int sz)
{
n=1; while(n<sz) n*=2;
node.resize(2*n-1, INF);
lazy.resize(2*n-1, 0);
lflg.resize(2*n-1, false);
}
void lazy2node(int k, int l, int r)
{
if(lflg[k])
{
node[k]=lazy[k];
lflg[k]=false;
prop(k, l, r);
}
}
void prop(int k, int l, int r)
{
if (r-l>0)
{
lazy[2*k+1]=lazy[2*k+2]=node[k];
lflg[2*k+1]=lflg[2*k+2]=true;
}
}
void update(int qa, int qb, int v, int k=0, int l=0, int r=-1)
{
if(r<0) r=n-1;
lazy2node(k, l, r);
if(qb<l || r<qa) return;
if(qa<=l && r<=qb)
{
node[k] = v;
prop(k, l, r);
}
else
{
int m=(l+r)/2;
update(qa, qb, v, 2*k+1, l, m);
update(qa, qb, v, 2*k+2, m+1, r);
}
}
int get(int qa, int qb, int k=0, int l=0, int r=-1)
{
if(r<0) r=n-1;
lazy2node(k, l, r);
if(qb<l || r<qa) return INF;
if(qa<=l && r<=qb) return node[k];
else
{
int m=(l+r)/2;
int lv = get(qa, qb, 2*k+1, l, m);
int lr = get(qa, qb, 2*k+2, m+1, r);
return min(lv, lr);
}
}
};
int main()
{
int n, q;
scanf("%d %d", &n, &q);
lst tree = lst(n);
for(int i=0; i<q; i++)
{
int t;
scanf("%d", &t);
if(t)
{
int s;
scanf("%d", &s);
printf("%d\n", tree.get(s,s));
}
else
{
int s, t, v;
scanf("%d %d %d", &s, &t, &v);
tree.update(s, t, v);
}
}
return 0;
}
| 1 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <string>
#include <cmath>
#include <complex>
#include <numeric>
#include <cassert>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <utility>
#define int64 long long
#define uint64 unsigned long long
using namespace std;
int main()
{
int64 nn, mm, dd;
long double ans = 0.0;
cin >> nn >> mm >> dd;
if(dd == 0)
{
ans += (long double)(mm - 1) / (long double)nn;
}
else
{
ans += (long double)(mm - 1) * 2.0 * (long double)(nn - dd) / (long double)(nn * nn);
}
cout << fixed << setprecision(20);
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define FOR(i,l,r) for(long long i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define RFOR(i,l,r) for(long long i=(l);i>=(r);--i)
#define RREP(i,n) RFOR(i,n-1,0)
#define RREPS(i,n) RFOR(i,n,1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
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; }
const int INF = 1e18;
signed main(){
double n, m, d; cin >> n >> m >> d;
double ans = max(n-d,0.0)*(d !=0 ? 2 : 1) / (n*n) * (m-1);
cout << fixed << setprecision(20.20) << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace::std;
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream& operator>>(istream& I, vector<T>& v) {for (T &e: v) I >> e; return I;}
template <class T> ostream& operator<<(ostream &O, const vector<T>& v) {for (const T &e: v) O << e << ' '; return O;}
void _main() {
int n; cin >> n;
map<int, int> freq;
while (n--) {
int a; cin >> a;
freq[a]++;
}
vector<int> candidates;
for (const auto it: freq) {
if (it.second >= 2) candidates.emplace_back(it.first);
if (it.second >= 4) candidates.emplace_back(it.first);
}
sort(all(candidates), greater<>());
if (candidates.size() < 2) cout << 0;
else cout << (ll) candidates[0] * candidates[1];
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// freopen("input.txt", "r", stdin);
int _t = 1;
// cin >> _t;
while (_t--) _main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define print cout <<
#define printl(s) cout << s << endl;
#define rep(i,n) for (int i = 0; i < (n); ++i)
using ll = long long;
const ll modseed = pow(10,9) + 7;
template <typename T>
vector<T> getValues(int num){
vector<T> values(num);
for(int i=0;i<num;i++){
cin >> values.at(i);
}
return values;
}
int calcDigit(ll N){
int digit = 0;
while(N>0){
N/= 10;
digit++;
}
return digit;
}
int main(){
ll N;
cin >> N;
int ans = calcDigit(N);
for(ll A=1;A*A<=N;A++){
if(N%A!=0){
continue;
}
ll B = N /A;
int tmp = max(calcDigit(A),calcDigit(B));
if(ans > tmp){
ans = tmp;
}
}
printl(ans);
}
| 0 |
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define rp(a) while(a--)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
int main(){
int n;
cin>>n;
string s;
getline(cin,s);
while(n--){
getline(cin,s);
if(s.size()>6)rep(i,s.size()-6)if(s.substr(i,7)=="Hoshino")s[i+6]='a';
cout<<s<<endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> v(n);
for(int i=0; i<n; i++) cin >> v[i];
for(int i=n-1; i>=0; i--){
if(i != n-1) cout << " ";
cout << v[i];
}
cout << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <string>
using std::cin;
using std::cout;
using std::endl;
char encode(char c, int n) {
char ret = c;
for (int i = 0; i < n; i++) {
if (ret == 'a') {
ret = 'Z';
}
else if (ret == 'A') {
ret = 'z';
}
else {
ret -= 1;
}
}
return ret;
}
int main(void) {
int n;
cin >> n;
while (n != 0) {
std::vector<int> k(n);
std::string str;
for (int i = 0; i < n; i++) {
cin >> k[i];
}
cin >> str;
for (int i = 0; i < str.length(); i++) {
cout << encode(str[i], k[i%n]);
}
cout << endl;
cin >> n;
}
return 0;
} | #include<iostream>
using namespace std;
#define MAX 100
#define BLANK 0
#define LONG 4
#define SHORT 2
#define HORIZONTAL 0
#define VERTICAL 1
#define VISITED 9
int field[MAX+2][MAX+2];
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
void rec(int x,int y,int c)
{
int i;
if(field[x][y]!=c)return;
field[x][y]=VISITED;
for(i=0;i<4;i++)rec(x+dx[i],y+dy[i],c);
return;
}
int main()
{
int w,h,xs,ys,xg,yg,n,c,d,x,y;
int i,j;
while(cin>>w>>h>>xs>>ys>>xg>>yg>>n,w|h){
for(j=1-1;j<=h+1;j++)for(i=1-1;i<=w+1;i++)field[i][j]=BLANK;
while(n-->0){
cin>>c>>d>>x>>y;
if(d==HORIZONTAL)
for(i=0;i<LONG;i++)for(j=0;j<SHORT;j++)field[x+i][y+j]=c;
else
for(i=0;i<SHORT;i++)for(j=0;j<LONG;j++)field[x+i][y+j]=c;
}
if(field[xs][ys]!=BLANK)rec(xs,ys,field[xs][ys]);
puts(field[xg][yg]==VISITED?"OK":"NG");
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
/***********debug tools***********/
template<class T> inline ostream& operator<<(ostream& os,vector<T> arr) {os << "["; for(int i = 0; i < (int)arr.size(); i++)os << arr[i] << (i == (int)arr.size() - 1 ? "]" : ",");os << endl;return os;}
template<typename A, typename B> ostream& operator<<(ostream& os, const pair<A,B>& p){os << "{" << p.first << "," << p.second << "}";return os; }
#define prvec(v) cerr<<#v<<": [";for(int __i = 0;__i < (int)(v).size(); __i++)cerr<<((v)[__i])<<(__i+1==(int)(v).size()?"]\n":",");
#define print(x) cerr<<#x<<": "<<(x)<<endl
/*********************************/
const int D = 30;
const int MAX_N = 100000;
int n, l;
vector<int> x;
vector<vector<int>> tor, tol;
void ftor() {
for(int i = 0; i < n; i++) {
int L = i + 1, R = n; //ooooxxx
while(R - L > 1) {
int mid = (L + R) / 2;
(x[mid] - x[i] <= l ? L : R) = mid;
}
tor[0][i] = L;
}
tor[0][n - 1] = n - 1;
for(int i = 0; i < D - 1; i++) {
for(int j = 0; j < n; j++) {
tor[i + 1][j] = tor[i][tor[i][j]];
}
}
}
void ftol() {
for(int i = 1; i < n; i++) {
int L = -1, R = i - 1;//xxxxxoooo
while(R - L > 1) {
int mid = (L + R) / 2;
(x[i] - x[mid] <= l ? R : L) = mid;
}
tol[0][i] = R;
}
tol[0][0] = 0;
for(int i = 0; i < D - 1; i++) {
for(int j = 0; j < n; j++) {
tol[i + 1][j] = tol[i][tol[i][j]];
}
}
}
int main()
{
cin >> n;
x.resize(n), tor.resize(D, vector<int>(n));
tol = tor;
for(int i = 0; i < n; i++)cin >> x[i];
cin >> l;
ftor();
ftol();
int Q; cin >> Q;
while(Q--) {
int a, b;
cin >> a >> b;
a--,b--;
if(a > b) {
int l = 0, r = 2 * n;//xxxxxxoooo
while(r - l > 1) {
int mid = (l + r) / 2;
int pos = a;
for(int i = 0; i < D; i++) {
if(mid & (1<<i))pos = tol[i][pos];
}
(pos <= b ? r : l) = mid;
}
cout << r << endl;
} else {
int l = 0, r = 2 * n;//xxxxxxoooo
while(r - l > 1) {
int mid = (l + r) / 2;
int pos = a;
for(int i = 0; i < D; i++) {
if(mid & (1<<i))pos = tor[i][pos];
}
(pos >= b ? r : l) = mid;
}
cout << r << endl;
}
}
}
| #include "bits/stdc++.h"
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL<<60;
const long long int Mod = 1000000007;
using ll = long long int; using ci = const int;
using vi = vector<int>; using Vi = vector<long long int>;
using P = pair<int, int>; using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define rep(i,N) for(ll i = 0; i < (ll)N; i++)
#define repi(i,a,b) for(ll i = ll(a); i < ll(b); ++i)
template<class T>bool chmax(T &former, const T &b) { if (former<b) { former=b; return true; } return false; }
template<class T>bool chmin(T &former, const T &b) { if (b<former) { former=b; return true; } return false; }
template<class T>T sqar(T x){ return x*x; }//sqrt(x)は平方根;
#define Sort(v) std::sort(v.begin(), v.end(), std::greater<decltype(v[0])>()) //降順でVをソート
#define p_queue(v) priority_queue<v, vector<v>, greater<v> >
template<class T> inline void princ(T x){cout<<x<<" ";};
template<class T> inline void print(T x){cout<<x<<"\n";};
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
///////////////////////////////////////////////////////////////////////////////////
ll m;
map<ll,ll> ma;
Vi d,c;
bool ck(){
ll sum = 0;
rep(i,10){
sum += ma[i];
if(sum>=2)return true;
}
return false;
}
int main(){
cin.tie(0);ios::sync_with_stdio(false);
std::cout<<std::fixed<<std::setprecision(30);
cin>>m;
d.resize(m);
c.resize(m);
rep(i,m){
cin>>d[i]>>c[i];
ma[d[i]] += c[i];
}
ll ans = 0;
while(ck()){
rep(i,10){
ll sum = 0;
if(i==0){
if(ma[i]<2)continue;
ans += ma[i]-1;
ma[i] = 1;
}else{
while(ma[i]>1){
if(ma[i]*i<10){
sum = ma[i]*i;
ans += ma[i]-1;
ma[i] = 0;
ma[sum]++;
}else{
ll tmp = 10/i;
if(10%i==0){
tmp--;
}
tmp++;
ll ret = ma[i]/tmp;
ma[i]%=tmp;
sum = tmp*i;
sum = sum%10 + sum/10;
ans += tmp*ret;
ma[sum]+=ret;
}
}
}
}
rep(i,10){
if(ma[i]==0)continue;
repi(j,i+1,10){
if(ma[i]==0)continue;
if(ma[j]==0)continue;
ll sum = i+j;
ans++;
if(sum>=10)ans++;
sum = sum/10 + sum%10;
ma[i]--;
ma[j]--;
ma[sum]++;
}
}
}
print(ans);
return 0;
} | 0 |
#include<iostream>
using namespace std;
#include<string>
#include<strstream>
#include<sstream>
#include<algorithm>
#include<math.h>
#include<iomanip>
#include<set>
long long mod = 10e18;
long long is(int n)
{
if (n == 0)
return 2;
if (n == 1)
return 1;
return (is(n - 1) + is(n - 2));
}
int main()
{
int n, k; cin >> n >> k; int j = 1;
j += j;
for (int i = 2; i <= n; ++i)
{
if (j < k)
{
j += j;
}
else
j += k;
}
cout << j;
} | #include<iostream>
#include<cstdio>
#include<map>
using namespace std;
#define int long long
map<char, int> m={
{'I',1},
{'V',5},
{'X',10},
{'L',50},
{'C',100},
{'D',500},
{'M',1000},
};
signed main(){
char buf[256];
while( scanf("%s", buf) != EOF ){
int ans = 0;
for(int i=0; i<256 && buf[i]!=0;i++){
if(buf[i+1]==0){
ans+=m[buf[i]];
}else{
if(m[buf[i]]<m[buf[i+1]]) ans-=m[buf[i]];
else ans+=m[buf[i]];
}
}
cout << ans<< endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ll long long
#define FASTIO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define inf 1e18
#define ff first
#define ss second
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define mod 1000000007
#define pb push_back
#define all(s) s.begin(),s.end()
#define pie 3.14159265358979323846
#define fr(i,a,b) for(ll i=a;i<b;i++)
#define frr(i,a,b) for(ll i=b-1;i>=a;i--)
#define gcd __gcd
#define con continue
#define pii pair<ll,ll>
signed main(){
FASTIO;
ll tt=1;
//cin>>tt;
while(tt--){
ll n,ans=0,x,mx=0;cin>>n;
for(ll i=0;i<n;i++){
cin>>x;
if(mx>x)ans+=mx-x;
mx=max(mx,x);
}
cout<<ans<<"\n";
}
}
| #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REP1(i, n) for(int i = 1; i <= (n); i++)
#define REPD(i,a,b) for (int i=(a);i<(b);i++)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long ll;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef set<int> si;
typedef vector<si> vsi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<int, int> pi;
typedef queue<int> qi;
typedef queue<pi> qpi;
typedef pair<ll, ll> pll;
typedef queue<pll> qpll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
const int mod = 1000000007;
const int INF = 1001001001;
// 小数点 << fixed << setprecision(0) <<
// sort降順 sort(ALL(),greater<int>());
// 円周率 M_PI
// 文字判定 isupper islower
// 文字変換
// 順列 do {} while(next_permutation(ALL(X)));
// 最大値 LLONG_MAX
// a内でx以上 auto iter = lower_bound(ALL(a), x);
// a内でxより大きい auto iter = upper_bound(ALL(a), x);
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
struct edge {
int from; //出発点
int to; //到達点
int cost; //移動コスト
};
typedef struct edge se;
typedef vector<edge> ve;
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;
}
vpll PrimeFactorization(ll n) {
vpll res;
for (ll i=2; i*i<=n; i++) {
if(n%i!=0) continue;
ll ex=0;
while(n%i==0) {
ex++;
n/=i;
}
res.push_back(pll(i,ex));
}
if(n!=1) res.push_back(pll(n,1));
return res;
}
int main() {
int k;
vi a(3);
cin >> a[0] >> a[1] >> a[2] >> k;
sort(ALL(a));
int ans=a[0]+a[1]+a[2]*pow(2,k);
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main() {
int n;
while(1){
cin >> n;
if(n == 0) break;
int num[10000][2] = {};
int score[2] = {};
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < 2; ++j){
cin >> num[i][j];
}
if (num[i][0] > num[i][1])
{
score[0] += num[i][0] + num[i][1];
} else if (num[i][0] == num[i][1])
{
score[0] += num[i][0];
score[1] += num[i][1];
} else{
score[1] += num[i][0] + num[i][1];
}
}
cout << score[0] << " " << score[1] << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int result[200] = { 0 };
int main(){
int num;
int tmp1, tmp2, sc1 = 0, sc2= 0;
while (cin >> num){
sc1 = sc2 = 0;
if (num == 0)break;
for (int i = 0; i < num; i++){
cin >> tmp1 >> tmp2;
if (tmp1 == tmp2){
sc1 += tmp1;
sc2 += tmp2;
}
else if (tmp1 > tmp2)
sc1 += tmp1 + tmp2;
else if (tmp1 < tmp2)
sc2 += tmp1 + tmp2;
}
cout << sc1 << " " << sc2 << endl;
}
} | 1 |
#include <iostream>
#include <vector>
#include <cassert>
#include <cmath>
using ll = long long;
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
int const nmax = 200;
ll v[1 + nmax];
class IndependentSet{
private:
std::vector<std::pair<ll,int>> v;
public:
ll reduce(ll number) {
for(int i = 0; i < v.size(); i++)
if(0 < ((1LL<<v[i].second) & number))
number ^= v[i].first;
return number;
}
void _insert(ll number) {
number = reduce(number);
if(0 < number)
v.push_back({number, __builtin_ctzll(number)});
}
};
int solve() {
int n;
std::cin >> n;
for(int i = 1; i <= n; i++)
std::cin >> v[i];
std::string s;
std::cin >> s;
s = "#" + s;
IndependentSet myset;
for(int i = n; 1 <= i; i--) {
if(s[i] == '0')
myset._insert(v[i]);
else {
if(0 < myset.reduce(v[i]))
return 1;
}
}
return 0;
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int t;
std::cin >> t;
for(int testcase = 1; testcase <= t; testcase++)
std::cout << solve() << '\n';
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1000000007;
#define INF 1LL<<30
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
// a^n mod を計算する
// O(logn)
ll modpow(ll a, ll n, ll mod=998244353) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll cnt[100010];
int main(){
int n;
cin>>n;
vector<ll> d(n);
rep(i,n){
cin>>d[i];
cnt[d[i]]++;
}
if(d[0]!=0 || cnt[0]!=1){
cout<<0<<endl;
return 0;
}
ll ans=1;
for(int i=1;i<100010;i++){
ll tmp=modpow(cnt[i],cnt[i+1]);
ans=(ans*tmp)%998244353;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define REP(a,b) for(int a=0;a<(b);++a)
#define REP1(i,n) for(int i=1;i<=(n);++i)
#define debug(x) cerr<<#x<<": "<<x<<'\n'
#define all(x) (x).begin(),(x).end()
#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 isYes(x) printf("%s\n",(x) ? "Yes" : "No")
#define isPossible(x) printf("%s\n",(x) ? "Possible" : "Impossible")
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
// #define INF (1<<29)
const long long INF = 1LL<<60;
#define Sp(p) cout<<setprecision(25)<< fixed<<p<<endl
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
#define pie 3.14159265358979323846
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef pair<int, P> PP;
typedef pair<ll, LP> LPP;
template<class T=int>
T in(){T x;cin>>x;return (x);}
template<class T>
void print(T& x){cout<<x<<'\n';}
const int MOD =(int)1e9+7;
// const int mod =(int)998244353;
const int mod =(int)1e9+7;
const int MAX =510000;
ll fac[MAX],finv[MAX],inv[MAX];
void COMint(){
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;
}
ll gcd(ll a,ll b){
if(a<0)a=-a;
if(b<0)b=-b;
if(b==0)return a;
if(a>b){
swap(a,b);
}
return gcd(a,b%a);
}
ll lcm(ll a,ll b){
if(a<0)a=-a;
if(b<0)b=-b;
ll g;g=gcd(a,b);
return b/g*a;
}
bool compare_by_b(pair<int, int> a, pair<int, int> b) {
if(a.second != b.second){
return a.second < b.second;
}else{
return a.first < b.first;
}
}
bool compare_by_a(pair<int, int> a, pair<int, int> b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll RS(ll N,ll P,ll m){
if(P==0){
return 1;
}else{
if(P%2==0){
ll t=RS(N,P/2,m);
return t*t%m;
}else{
return N*RS(N,P-1,m)%m;
}
}
}
bool greater_pair(pair<ll,ll> a,pair<ll,ll> b){
if(a.first!=b.first){
return a.first>b.first;
}else{
return a.second>b.second;
}
}
int N;
vector<vector<int>> to(100100);
vector<int> parent(100100,-1);
vector<int> depth(100100,-1);
vector<int> level(100100,-1);
vector<int>checked(100100,0);
int f(int i){
checked[i]=1;
int res=0;
REP(ni,to[i].size()){
if(checked[to[i][ni]]!=0)continue;
parent[to[i][ni]]=i;
level[to[i][ni]]=level[i]+1;
res=max(res,1+f(to[i][ni]));
}
return depth[i]=res;
}
int main() {
ios::sync_with_stdio(false);
cin>>N;
int v,u;cin>>u>>v;--v,--u;
REP(i,N-1){
int a,b;cin>>a>>b;--a;--b;
to[a].pb(b);
to[b].pb(a);
}
parent[v]=-1;
level[v]=0;
int d=f(v);
int ans=0;
if(level[u]%2==0)ans++;
int temp=(level[u]-1)/2;
REP(i,temp){
u=parent[u];
ans++;
}
ans+=depth[u];
cout<<ans<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
vector<int>adj[100003],leaf;
int par[100003],depth[100005],sparse[100005][20],root=0,lz=0;
int lca(int p,int q)
{
int a,b,c,d,lp,i,j;
if(depth[p]<depth[q])
{
c=p; p=q; q=c;
}
for(j=19;j>=0;j--)
{
if((depth[p]-(1 << j))>=depth[q])
{
p=sparse[p][j]; if(depth[p]==depth[q])break;
}
}
if(p==q){ return p; }
else
{
for(j=19;j>=0;j--)
{
if(sparse[p][j]!=0 && sparse[p][j]!=sparse[q][j])
{
p=sparse[p][j]; q=sparse[q][j];
if(par[p]==par[q])break;
}
}
return par[p];
}
}
void dfs(int src)
{
int sz=adj[src].size();
if(sz==1 && src!=root){ leaf.push_back(src); lz++; }
for(int lp=0;lp<sz;lp++)
{
int u=adj[src][lp];
if(u!=root && par[u]==0)
{
par[u]=src; sparse[u][0]=src; depth[u]=depth[src]+1;
dfs(u);
}
}
}
int main()
{
int n,m,a,b,i,j,u,v,ans,z,x,y,fr,sc,tr,w;
scanf("%d %d %d",&n,&u,&v);
for(i=1;i<=n-1;i++)
{
scanf("%d %d",&a,&b);
adj[a].push_back(b); if(root==0){ if(adj[a].size()==2)root=a; }
adj[b].push_back(a); if(root==0){ if(adj[b].size()==2)root=b; }
}
if(n==2)printf("0\n");
else
{
dfs(root);
for(j=1;j<=19;j++)
{
for(i=1;i<=n;i++)
{
if(sparse[i][j-1]!=0)
{
sparse[i][j]=sparse[sparse[i][j-1]][j-1];
}
}
}
m=lca(u,v);
ans=(depth[v]-depth[m])+(depth[u]-depth[m]); ans=ans-1;
for(i=0;i<lz;i++)
{
y=leaf[i]; m=lca(u,y); w=lca(v,y);
fr=(depth[u]-depth[m])+(depth[y]-depth[m]);
sc=(depth[v]-depth[w])+(depth[y]-depth[w]);
if(fr<sc)
{
if(sc-1>ans)ans=sc-1;
}
}
printf("%d\n",ans);
}
return 0;
}
| 1 |
# include <bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin>>N;
long long A[N];
long long O[65];
for(long long i=0;i<65;i++){
O[i]=0;
}
for(long long i=0;i<N;i++){
cin>>A[i];
int count=0;
long long temp=A[i];
while(temp!=0){
O[count]+= temp%2;
temp/=2;
count++;
}
//cout<<i<<" "<<A[i]<<" "<<count<<" "<<O[count]<<endl;
}
long long ans=0;
long long t=1;
for(long long i=0;i<63;i++){
ans=(ans+((t*O[i])%1000000007)*(N-O[i]))%1000000007;
t=(t*2)%1000000007;
//cout<<i<<" "<<O[i]<<" "<<ans<<endl;
}
cout<<ans<<endl;
return 0;
}
| #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> //required
#include <ext/pb_ds/tree_policy.hpp> //required
using namespace __gnu_pbds;
using namespace std;
template <typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k) returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;
typedef long long ll;
typedef vector<ll> VL;
typedef vector<int> VI;
typedef pair<ll,ll> PLL;
typedef pair<int,int> PII;
#define pb push_back
#define F first
#define S second
#define SZ(a) int((a).size())
#define ALL(a) a.begin(),a.end()
#define fr(i,x,y) for(int i=x;i<y;i++)
#define frr(i,x,y) for(int i=x-1;i>=y;i--)
#define inf 1e18+1
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const int mod=1000000007;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
ll power(ll a,ll b){ll ans=1;while(b!=0){if(b&1){ans*=a;}a=a*a;b>>=1;}return ans;}
ll powerm(ll a,ll b){ll ans=1;while(b!=0){if(b&1){ans*=a;ans%=mod;}a=a*a;a%=mod;b>>=1;}return ans%mod;}
// string to integer stoi()
// string to long long stoll()
// string.substr(position,length);
// integer to string to_string();
void solve()
{
ll n;
cin>>n;
vector<VL> pref(n+2,VL(60,0));
VL arr(n);
fr(i,0,n)
{
cin>>arr[i];
ll x=arr[i];
fr(j,0,60)
{
if(x&(1LL<<j))
{
pref[i+1][j]=1;
}
}
}
fr(j,0,60)
{
frr(i,n+1,1)
{
pref[i][j]+=pref[i+1][j];
}
}
ll ans=0;
fr(i,0,n-1)
{
//cin>>arr[i];
ll x=arr[i];
ll rem=n-(i+1);
fr(j,0,60)
{
if(x&(1LL<<j))
{
ans+=(powerm(2,j)*(rem-pref[i+2][j])%mod);
//scout<<x<<' '<<j<<endl;
}
else
{
ans+=(powerm(2,j)*(pref[i+2][j])%mod);
}
ans%=mod;
}
}
cout<<ans<<endl;
return;
}
int main()
{
IOS;
ll t=1;
//cin>>t;
while(t--)
{
//cout<<"Case #"<<pp-t<<":\n";
solve();
}
return 0;
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
*/
/*
recursion - matrix exponential
*/
// BITMASK:
// 1)When some constrall is of the order of 15-20, think of bitmask DP.
// 2)When some constrall is around 40, try out meet in the middle
// 3) See Strings,palindromes,prefix,suffix etc -> KMP,Z algorithm | 1 |
#include <stdio.h>
#include <algorithm>
int n, t, x;
int a[100000];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
std::sort(a, a + n);
t = 1;
for (int i = 0; i < n; i++) {
if (i == n - 1 || a[i] != a[i + 1]) {
if (t % 2)x++;
t = 1;
}
else t++;
}
printf("%d\n", x);
} | #include<iostream>
#include<string>
using namespace std;
string data[22];
int solve(int x, int y){
if(x < 0 || y < 0 || x == 12 || y == 12 || data[y][x] == '0') return 0;
data[y][x] = '0';
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
for(int i=0;i<4;i++) solve(x+dx[i], y+dy[i]);
return 1;
}
int main(){
while(cin >> data[0]){
for(int i=1;i<12;i++) cin >> data[i];
int ans = 0;
for(int i=0;i<12;i++) for(int j=0;j<12;j++) ans += solve(i, j);
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0, a1, a2, a3, a4, x, ...) x
#define dump_1(x1) cerr << #x1 << ": " << x1 << endl
#define dump_2(x1, x2) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << endl
#define dump_3(x1, x2, x3) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << endl
#define dump_4(x1, x2, x3, x4) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << endl
#define dump_5(x1, x2, x3, x4, x5) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << ", " #x5 << ": " << x5 << endl
#define dump(...) \
CHOOSE((__VA_ARGS__, dump_5, dump_4, dump_3, dump_2, dump_1, ~))(__VA_ARGS__)
#define check(s) cerr << s << endl
#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(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
using ll = long long;
const long long MOD = 1000000007;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
const ll LINF = 2e18;
const int INF = 1e9;
void solve(std::string K, ll D) {
ll N = K.size();
vector<vector<vector<ll>>> dp(N + 1,
vector<vector<ll>>(2, vector<ll>(D + 1)));
dp[0][0][0] = 1;
FOR(i, 0, N) {
ll k = K.at(i) - '0';
FOR(j, 0, D) {
FOR(dig, 0, 10) { (dp[i + 1][1][(j + dig) % D] += dp[i][1][j]) %= MOD; }
FOR(dig, 0, k) { (dp[i + 1][1][(j + dig) % D] += dp[i][0][j]) %= MOD; }
(dp[i + 1][0][(j + k) % D] += dp[i][0][j]) %= MOD;
}
}
ll ans = (dp[N][0][0] + dp[N][1][0] - 1 + MOD) % MOD;
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
std::string K;
std::cin >> K;
ll D;
cin >> D;
solve(K, D);
return 0;
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <deque> // deque
#include <iomanip> // fixed, setprecision
#include <iostream> // cout, endl, cin
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <string> // string, to_string, stoi
#include <tuple> // tuple, make_tuple
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <utility> // pair, make_pair
#include <vector> // vector
using namespace std;
int main() {
int N, L, t, s = 0, mdiff = 20000, mt;
cin >> N >> L;
for (int i = 0; i < N; i++) {
t = L + i;
if (abs(t) < mdiff) {
mdiff = abs(t);
mt = t;
}
s += t;
}
cout << s - mt << endl;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <string>
using namespace std;
int main() {
string s; cin >> s;
for(int i = s.size()-1; i >= 0; i--) printf("%c", s[i]);
cout << endl;
} | #include<bits/stdc++.h>
using namespace std;
signed main(void){
ios::sync_with_stdio(false);
int d,ans;
while(cin>>d){
ans=0;
for(int i=0;i<600;i+=d)
ans+=i*i*d;
cout<<ans<<endl;
}
} | 0 |
/*
* sto Qingyu orz
* 感谢真神sqy无私的教诲。膜时队者处处阿克，只因大师sqy在他背后。不膜大师者违背了真神的旨意，真神必将降下天谴,
* 使其天天爆零
* 我不由自主地膜拜真神sqy。
* Author: RainAir
* Time: 2019-10-16 10:11:35
*/
#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <cstdio>
#include <bitset>
#include <vector>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define fi first
#define se second
#define U unsigned
#define P std::pair
#define LL long long
#define pb push_back
#define MP std::make_pair
#define all(x) x.begin(),x.end()
#define CLR(i,a) memset(i,a,sizeof(i))
#define FOR(i,a,b) for(int i = a;i <= b;++i)
#define ROF(i,a,b) for(int i = a;i >= b;--i)
#define DEBUG(x) std::cerr << #x << '=' << x << std::endl
const int MAXN = 5000+5;
const int ha = 998244353;
int cnt[MAXN];
int n,k,fac[MAXN],inv[MAXN];
inline int qpow(int a,int n=ha-2){
int res = 1;
while(n){
if(n & 1) res = 1ll*res*a%ha;
a = 1ll*a*a%ha;
n >>= 1;
}
return res;
}
inline void prework(){
fac[0] = 1;
FOR(i,1,MAXN-1) fac[i] = 1ll*fac[i-1]*i%ha;
inv[MAXN-1] = qpow(fac[MAXN-1]);
ROF(i,MAXN-2,0) inv[i] = 1ll*inv[i+1]*(i+1)%ha;
}
inline int C(int n,int m){
if(n < m) return 0;
return 1ll*fac[n]*inv[m]%ha*inv[n-m]%ha;
}
int main(){
scanf("%d%d",&k,&n);
prework();
FOR(i,1,k) cnt[i+1]++,cnt[i+k+1]--;
FOR(i,1,2*k) cnt[i] += cnt[i-1],cnt[i-1] = (cnt[i-1]+1)/2;
// FOR(i,1,2*k) DEBUG(cnt[i]);
FOR(i,2,k*2){
int ans = 0;
FOR(j,0,std::min(cnt[i],n/2)){
(ans += 1ll*((j&1)?ha-1:1)*C(cnt[i],j)%ha*C(n-2*j+k-1,k-1)%ha)%=ha;
}
printf("%d\n",ans);
}
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main(){
ll n = 0;
ll m = 0;
cin >> n >> m;
vector<ll> a(n);
vector<ll> b(m);
map<ll,ll> ac;
map<ll,ll> bc;
for(int i = 0;i < n;i++)cin >> a[i],ac[a[i]]++;
for(int i = 0;i < m;i++)cin >> b[i],bc[b[i]]++;
if((ll)ac.size() != n || (ll)bc.size() != m){
cout << 0 << endl;
return 0;
}
vector<ll> awa(n*m);
vector<ll> bwa(n*m);
for(int i = n*m - 1;i >= 0;i--){
if(ac[i + 1] == 1)awa[i] = 1;
if(i != n*m - 1)awa[i] += awa[i + 1];
}
for(int i = n*m - 1;i >= 0;i--){
if(bc[i + 1] == 1)bwa[i] = 1;
if(i != n*m - 1)bwa[i] += bwa[i + 1];
}
ll res = 1;
ll mod = pow(10,9) + 7;
for(int i = n*m - 1;i >= 0;i--){
if(ac[i + 1] == 1 && bc[i + 1] == 0)res *= max((ll)0,bwa[i + 1]);
if(ac[i + 1] == 0 && bc[i + 1] == 1)res *= max((ll)0,awa[i + 1]);
if(ac[i + 1] == 0 && bc[i + 1] == 0)res *= max((ll)0,awa[i + 1] * bwa[i + 1] - (n*m - i - 1));
res %= mod;
}
cout << res << endl;
} | 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;}
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
int n,a,b;
cin >> n;
if(n==2) {
cin >> a >> b;
cout << a + b << endl;
} else {
cout << "Hello World\n" << endl;
}
return 0;
}
| 1 |
#include <bitset>
#include <cmath>
#include <iostream>
using namespace std;
int a(int i) {
int ret{};
for (int j = 0; j != i; ++j) {
ret += lround(pow(2, 2 * j + 1));
}
return ret;
}
int main() {
long long N;
cin >> N;
bitset<64> ans;
for (int i = 0; i != 16; ++i) {
auto x = ((N + a(i)) >> 2*i) % 4;
ans.set(2 * i + 1, x & 0x2);
ans.set(2 * i, x & 0x1);
}
bool flag{false};
for (int i = 31; i >= 0; --i) {
if (flag |= ans.test(i), !flag) continue;
cout << ans.test(i);
}
if (!flag) cout << 0;
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main(){
ll N;
cin >> N;
if (N == 0){
cout << '0' << endl;
exit(0);
}
vector<ll> bin(0);
while (N != 1){
ll amari = N % -2;
if (amari >= 0){
bin.push_back(amari);
N /= -2;
}
else{
bin.push_back(1);
N /= -2;
N += 1;
}
}
bin.push_back(1);
for (ll i = bin.size() - 1; i >= 0; i--){
ll a = bin.at(i);
cout << a;
}
cout << endl;
/*ll a = N % -2;
ll b = N / -2;
cout << a << ' ' << b << endl;*/
} | 1 |
#include<iostream>
#include<string>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<list>
#include<iomanip>
#include<vector>
#include<random>
#include<functional>
#include<algorithm>
#include<stack>
#include<cstdio>
#include<bitset>
#include<unordered_map>
#include<climits>
#include<fstream>
using namespace std;
///////////////////library zone!!!!!!!!!!!!!!!!!!!!!!!!!!!!
typedef long long ll;
typedef long double ld;
#define all(a) (a).begin(),(a).end()
const ll Mod = 1000000007;
const ll mod = 998244353;
struct H {
ll x, y;
bool operator<(const H &b) const {
if (x != b.x) return x < b.x;
return y < b.y;
}
bool operator>(const H &b) const {
if (x != b.x) return x > b.x;
return y > b.y;
}
bool operator==(const H &b) const { return x == b.x&&y == b.y; }
bool operator!=(const H &b) const { return (*this) != b; }
};
struct P {
ll pos, cost;
bool operator<(const P &b) const { return cost < b.cost; }
bool operator>(const P &b) const { return cost > b.cost; }
};
struct B {
ll to, cost;
};
struct E {
ll from, to, cost;
bool operator<(const E &b) const { return cost < b.cost; }
bool operator>(const E &b) const { return cost > b.cost; }
};
template<typename T, typename U>
void chmin(T &a, U b) {
if (a > b) a = b;
}
template<typename T, typename U>
void chmax(T &a, U b) {
if (a < b) a = b;
}
template<typename T>
T max_0(T a) {
if (a < 0) return 0;
return a;
}
template<typename T>
T min_0(T a) {
if (a > 0) return 0;
return a;
}
ll read() {
ll u;
scanf("%lld", &u);
return u;
}
ll gcd(ll i, ll j) {
if (i > j) swap(i, j);
if (i == 0) return j;
return gcd(j%i, i);
}
ll mod_pow(ll x, ll n, ll p) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * x % p;
x = x * x % p;
n >>= 1;
}
return res;
}//x^n%p
const ll Inf = 3023372036854775807;
const int inf = 1500000000;
#define int long long
//----------------------------------------------------
int h, w;
bool a[3000][3000];
int b[3000][3000];
signed main() {
cin >> h >> w;
for (int i = 0; i < h; i++) {
string s;
cin >> s;
for (int j = 0; j < w; j++) {
if (s[j] == '#') a[i][j] = 1;
}
}
//bは、これより右でこことしたがの関係が同じところの長さ
for (int j = w - 1; j >= 0; j--) b[h - 1][j] = w - j;
for (int i = 0; i < h - 1; i++) {
for (int j = w - 1; j >= 0; j--) {
if (j == w - 1 || ((a[i][j] == a[i + 1][j]) != (a[i][j + 1] == a[i + 1][j + 1]))) {
b[i][j] = 1;
}
else {
b[i][j] = b[i][j + 1] + 1;
}
}
}
int ans = 0;
for (int j = 0; j < w; j++) {
stack<H>st;
//x=高さ、y=場所
for (int i = h - 1; i >= 0; i--) {
if (!st.empty() && st.top().x > b[i][j]) {
int k = i;
while (!st.empty() && st.top().x > b[i][j]) {
if (st.top().y == h - 1)
ans = max(ans, (st.top().y - i)*st.top().x);
else
ans = max(ans, (st.top().y - i + 1)*st.top().x);
k = st.top().y;
st.pop();
}
st.push(H{ b[i][j],k });
}
else if (st.empty() || st.top().x < b[i][j]) {
st.push(H{ b[i][j],i });
}
}
while (!st.empty()) {
if (st.top().y == h - 1)
ans = max(ans, (st.top().y + 1)*st.top().x);
else
ans = max(ans, (st.top().y + 2)*st.top().x);
st.pop();
}
}
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
typedef long double ld;
#define vec(s) vector<s>
#define vvec(s) vector<vector<s>>
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli,lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Yes(x) cout<<(x?"Yes":"No")<<endl;
#define YES(x) cout<<(x?"YES":"NO")<<endl;
#define out(s) cout<<s<<endl;
#define pb(s) push_back(s);
#define sp " "
#define INF 10000000000
#define LINF 9000000000000000000
#define all(s) s.begin(),s.end()
void vout(vi v){
for(lli i=0;i<v.size();i++)
cout<<v.at(i)<<endl;
}
int main(){
cout << std::fixed << std::setprecision(10);
lli a, b;
cin>>a>>b;
lli ans=0;
rep(i,2){
if(a>b){
ans+=a;
a--;
}
else{
ans+=b;
b--;
}
}
out(ans);
} | 0 |
#pragma warning(disable: 4996)
#include <string>
#include <vector>
#include <iostream>
#include <cstdio>
#include <sstream>
#include <fstream>
#include <math.h>
#include <algorithm>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < (n); i++)
int main() {
int n, m;
cin >> n >> m;
vector<int>s(m);
vector<int>c(m);
vector<int>cnt(3),cnt2(3);
rep(i, 3)cnt[i] = -101,cnt2[i] = 0;
int ans = 0;
rep(i, m) {
cin >> s[i] >> c[i];
if (n == 1) {
if (s[i] > 1) {
cout << -1 << endl;
return 0;
}
else {
if (cnt[0] != c[i] && cnt2[0] != 0) {
cout << -1 << endl;
return 0;
}
if (cnt2[0] == 0) {
ans += c[i];
}
cnt2[0]++;
cnt[0] = c[i];
}
}
else if (n == 2) {
if (s[i] > 2) {
cout << -1 << endl;
return 0;
}
else {
if (s[i] == 2) {
if (cnt[1] != c[i] && cnt2[1] != 0) {
cout << -1 << endl;
return 0;
}
if (cnt2[1] == 0) {
ans += c[i];
}
cnt2[1]++;
cnt[1] = c[i];
}
else if (s[i] == 1) {
if (cnt[0] != c[i] && cnt2[0] != 0) {
cout << -1 << endl;
return 0;
}
if (c[i] == 0) {
cout << -1 << endl;
return 0;
}
if (cnt2[0] == 0) {
ans += c[i] * 10;
}
cnt2[0]++;
cnt[0] = c[i];
}
}
}
else {
if (s[i] == 3) {
if (cnt[2] != c[i] && cnt2[2] != 0) {
cout << -1 << endl;
return 0;
}
if (cnt2[2] == 0) {
ans += c[i];
}
cnt2[2]++;
cnt[2] = c[i];
}
if (s[i] == 2) {
if (cnt[1] != c[i] && cnt2[1] != 0) {
cout << -1 << endl;
return 0;
}
if (cnt2[1] == 0) {
ans += c[i] * 10;
}
cnt2[1]++;
cnt[1] = c[i];
}
else if (s[i] == 1) {
if (cnt[0] != c[i] && cnt2[0] != 0) {
cout << -1 << endl;
return 0;
}
if (c[i] == 0) {
cout << -1 << endl;
return 0;
}
if (cnt2[0] == 0) {
ans += c[i] * 100;
}
cnt2[0]++;
cnt[0] = c[i];
}
}
}
if (n == 2 && cnt2[0] == 0)ans = ans + 10;
if (n == 3 && cnt2[0] == 0)ans = ans + 100;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
bool intCheck(int i, int N, int M, vector<int> S, vector<int> C) {
string sx = to_string(i);
if (sx.size() != N) return false;
for (int j = 0; j < M; j++) {
if (sx.at(S.at(j)) != (char)C.at(j) + '0') return false;
}
return true;
}
int main() {
int N, M; cin >> N >> M;
vector<int> s(M), c(M);
for (int i = 0; i < M; i++) {
cin >> s.at(i) >> c.at(i);
s.at(i)--;
}
bool ans = true;
int minv = 1e5, nf = -1;
for (int i = 0; i < 1000; i++) {
if (intCheck(i, N, M, s, c)) {
cout << i << endl;
return 0;
}
}
cout << nf << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
map<ll, ll> a;
for(int i = 0; i < N; i++) {
ll A;
cin >> A;
a[A]++;
}
vector<ll> x;
for(auto i = begin(a); i != a.end(); i++) {
for(int j = i -> second; j > 1; j -= 2) {
x.push_back(i -> first);
}
}
sort(x.begin(), x.end(), greater<ll>());
if(x.size() < 2) cout << 0 << endl;
else cout << x[0] * x[1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using pp=pair<int,char>;
using ll=long long;
int main() {
int N;
cin >> N;
vector<int> A(N), V(2, 0);
for (int i=0; i<N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
A.push_back(0);
int s=1;
for (int i=0; i<N; i++) {
if (A[i]==A[i+1]) {
s++;
}
else {
int a=A[i];
int n=s/2;
//cout << N << endl;
for (int j=0; j<n; j++) {
V.push_back(a);
}
s=1;
}
}
ll p=V[V.size()-1], q=V[V.size()-2];
sort(V.begin(), V.end());
cout << p*q << endl;
}
| 1 |
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define repc(i,s,e) for(int i=(s); i<(e); i++)
#define pb(n) push_back((n))
#define mp(n,m) make_pair((n),(m))
#define all(r) r.begin(),r.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<ll> vl;
typedef vector<vl> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1000000;
int main(){
int n, m;
cin>>n>>m;
vi v(n, 0);
vi u(n, 0);
for(int i = 0; i < n; i++) cin>>v[i];
int a;
for(int i = 0; i < m; i++){
cin>>a;
for(int i = 0; i < n; i++){
if(v[i] <= a){
//cout<<" "<<i;
u[i]++;
break;
}
}
}
//cout<<endl;
int ans = 0;
for(int i = 1; i < n; i++){
if(u[ans] < u[i]) ans = i;
}
cout<<ans+1<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repr(i,n) for(int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(),v.end()
typedef long long ll;
int main(){
int H,W;
cin >> H >> W;
vector<vector<int> > A(H, vector<int> (W)), B(H, vector<int> (W));
rep(i,H){
rep(j,W){
cin >> A[i][j];
}
}
rep(i,H){
rep(j,W){
cin >> B[i][j];
}
}
vector<vector<vector<int> > > dp(H, vector<vector<int> >(W, vector<int> (6480)));
rep(i,H){
rep(j,W){
rep(k,6480){
dp[i][j][k] = 0;
}
}
}
vector<vector<int> > C(H, vector<int> (W));
for (int i = 0; i < H; i++){
for (int j = 0; j < W; j++){
C[i][j] = abs(A[i][j] - B[i][j]);
}
}
dp[0][0][C[0][0]] = 1;
for (int i = 0; i < H - 1; i++){
for (int j = 0; j < W - 1; j++){
for (int k = 0; k < 6400; k++){
if (dp[i][j][k] > 0){
dp[i][j + 1][abs(k - C[i][j + 1])]++;
dp[i][j + 1][abs(k + C[i][j + 1])]++;
}
}
}
for (int j = 0; j < W; j++){
for (int k = 0; k < 6400; k++){
if (dp[i][j][k] > 0){
dp[i + 1][j][abs(k - C[i + 1][j])]++;
dp[i + 1][j][abs(k + C[i + 1][j])]++;
}
}
}
}
for (int j = 0; j < W - 1; j++){
for (int k = 0; k < 6400; k++){
if (dp[H - 1][j][k] > 0){
dp[H - 1][j + 1][abs(k - C[H - 1][j + 1])]++;
dp[H - 1][j + 1][abs(k + C[H - 1][j + 1])]++;
}
}
}
int ans = 6479;
for (int k = 6479; k >= 0; k--){
if (dp[H - 1][W - 1][k] > 0) ans = k;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#define int long long
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define F first
#define S second
using namespace std;
typedef pair<int,int> P;
typedef vector<int> ivec;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
const int MOD=1000000007;
int INF=100100100100100;
signed main(){
int n;cin>>n;
int ans=0;
string s[3];cin>>s[0]>>s[1]>>s[2];
rep(i,n){
char c[3];
rep(j,3)c[j]=s[j][i];
sort(c,c+3);
if(c[0]!=c[1])ans++;
if(c[1]!=c[2])ans++;
}
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<(int)n;i++)
using namespace std;
using qp=queue<pair<int,int>>;
int main(){
int H,W;
cin>>H>>W;
string s;
vector<string> S(H+2,string(W+2,'#'));
int cnt=0;
REP(h,H) {
cin>>s;
S[h+1]='#'+s+'#';
for(auto x: S[h+1]) if(x=='.') cnt++;
}
int I[H+2][W+2]={};
qp Q;
Q.push(make_pair(1,1));
I[1][1]=1;
int h,w,nh,nw;
int dh[4]={1, 0,-1, 0};
int dw[4]={0, 1, 0,-1};
while(!Q.empty()){
h=Q.front().first;
w=Q.front().second;
Q.pop();
REP(i,4){
nh=h+dh[i];
nw=w+dw[i];
if(S[nh][nw]=='.'&&I[nh][nw]==0){
Q.push(make_pair(nh,nw));
I[nh][nw]=I[h][w]+1;
}
}
}
int ans=(I[H][W])? cnt-I[H][W]: -1;
cout<<ans<<endl;
} | 0 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
int main(void){
char a;
bool contain = false;
rep(i, 3){
cin >> a;
if(a == '7'){
contain = true;
}
}
if(contain) cout << "Yes\n";
else cout << "No\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
int main() {
string s;
cin >> s;
if(s.size()%2 == 1){
cout << "No" << endl;
return 0;
}
rep(i,s.size()){
if(i%2 == 0 && s[i] != 'h'){
cout << "No" << endl;
return 0;
}
if(i%2 == 1 && s[i] != 'i'){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} | 0 |
#include <bits/stdc++.h>
#define ln '\n'
#define all(dat) dat.begin(), dat.end()
#define loop(i, to) for (int i = 0; i < to; ++i)
#define cont(i, to) for (int i = 1; i <= to; ++i)
#define circ(i, fm, to) for (int i = fm; i <= to; ++i)
#define foreach(i, dat) for (__typeof(dat.begin()) i = dat.begin(); i != dat.end(); ++i)
typedef long long num;
using namespace std;
const int nsz = 15, msksz = (1 << nsz) - 1, inf = 0x3f3f3f3f;
int n, m, full, lg[msksz + 5], g[nsz + 5], w[nsz + 5][nsz + 5], sum[msksz + 5], dp[msksz + 5][nsz + 5];
int inline at(int S, int id) { return S >> id & 1; }
int inline lowbit(int S) { return S & -S; }
string inline bin(int S, int len = n) {
string s;
loop (i, len) s += at(S, i) + 48;
return s;
}
void inline upd(int &a, int b) { if (a < b) a = b; }
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
full = (1 << n) - 1;
cont (i, m) {
int u, v, w;
cin >> u >> v >> w;
--u, --v;
g[u] |= 1 << v;
g[v] |= 1 << u;
::w[u][v] = ::w[v][u] = w;
}
loop (i, n) lg[1 << i] = i;
memset(sum, -inf, sizeof(sum));
sum[0] = 0;
cont (S, full) {
int u = lg[lowbit(S)];
sum[S] = sum[S - lowbit(S)];
for (int t = g[u] & S, d = t & -t; d; t -= d, d = t & -t) {
int v = lg[d];
sum[S] += w[u][v];
}
}
memset(dp, -inf, sizeof(dp));
cont (S, full) {
if (!at(S, 0) || at(S, n - 1)) continue;
dp[S][0] = sum[S];
}
circ (S, 0, full) {
for (int rS = (S ^ full), T = rS; T; T = (T - 1) & rS) {
if (sum[T] < 0) continue;
for (int t = S, d = t & -t; d; t -= d, d = t & -t) {
int u = lg[d];
if (dp[S][u] < 0) continue;
for (int t = T & g[u], d = t & -t; d; t -= d, d = t & -t) {
int v = lg[d];
upd(dp[S | T][v], dp[S][u] + sum[T] + w[u][v]);
}
}
}
}
cout << sum[full] - dp[full][n - 1] << ln;
} | #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
typedef pair < int, int > pii;
const int N = 16;
const int M = (1 << N);
const int INF = 0x3f3f3f3f;
int dp[N][M], g[N][N], n, m, rv[M];
int f(int st, int msk){
if(st == n - 1) return 0;
if(dp[st][msk] != -1) return dp[st][msk];
int sol = INF;
for(int msk1 = (msk - 1) & msk; msk1 ; msk1 = (msk1 - 1) & msk){
int msk2 = msk ^ msk1;
if(msk1 & (1 << (n - 1))) continue;
if(msk2 & (1 << st)) continue;
int sum = 0;
for(int t1 = msk1; t1 ; t1 -= t1 & (-t1)){
for(int t2 = msk2 ; t2 ; t2 -= t2 & (-t2)){
sum += g[rv[t1 & (-t1)]][rv[t2 & (-t2)]];
}
}
for(int t2 = msk2 ; t2 ; t2 -= t2 & (-t2)){
if(g[st][rv[t2 & (-t2)]]){
sol = min(sol, f(rv[t2 & (-t2)], msk2) + sum - g[st][rv[t2 & (-t2)]]);
}
}
}
return dp[st][msk] = sol;
}
int main(){
memset(dp, -1, sizeof(dp));
for(int i = 0;i<N;i++) rv[(1 << i)] = i;
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
for(int i = 0;i<m;i++){
int x, y;scanf("%d%d", &x, &y);x--;y--;
scanf("%d", &g[x][y]);
g[y][x] = g[x][y];
}
printf("%d\n", f(0, (1 << n) - 1));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N=1e3+5;
const int MOD=1e9+7;
int n, a, b, c, d;
int cache[N][N], cache2[N][N];
int fact[N], invfact[N];
int pow(int a, int b, int m)
{
int ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%m;
b/=2;
a=(a*a)%m;
}
return ans;
}
int modinv(int k)
{
return pow(k, MOD-2, MOD);
}
void precompute()
{
fact[0]=fact[1]=1;
for(int i=2;i<N;i++)
{
fact[i]=fact[i-1]*i;
fact[i]%=MOD;
}
invfact[N-1]=modinv(fact[N-1]);
for(int i=N-2;i>=0;i--)
{
invfact[i]=invfact[i+1]*(i+1);
invfact[i]%=MOD;
}
}
int nCr(int x, int y)
{
if(y>x)
return 0;
int num=fact[x];
num*=invfact[y];
num%=MOD;
num*=invfact[x-y];
num%=MOD;
return num;
}
int num(int r, int take)
{
int &ans=cache2[r][take];
if(ans!=-1)
return ans;
return modinv(pow(fact[r], take, MOD));
}
int dp2(int n, int r, int take)
{
int ans=fact[n] * invfact[n-r*take];
ans%=MOD;
int den=num(r, take);
ans*=den;
ans%=MOD;
return ans;
}
int dp(int remaining, int freq)
{
if(remaining==0)
return 1;
if(freq==b+1)
return 0;
int &ans=cache[remaining][freq];
if(ans!=-1)
return ans;
ans=dp(remaining, freq+1);
for(int i=c;i<=d;i++)
{
int take=i*freq;
if(take>remaining)
break;
int ways=dp2(remaining, freq, i);
ways*=dp(remaining-take, freq+1);
ways%=MOD;
ways*=invfact[i];
ways%=MOD;
ans+=ways;
}
ans%=MOD;
return ans;
}
int32_t main()
{
IOS;
precompute();
memset(cache, -1, sizeof(cache));
memset(cache2, -1, sizeof(cache2));
cin>>n>>a>>b>>c>>d;
int ans=dp(n, a);
cout<<ans;
cerr<<(double)clock()/CLOCKS_PER_SEC;
return 0;
} | #include <bits/stdc++.h>
#define all(vec) vec.begin(),vec.end()
using namespace std;
using ll=long long;
using P=pair<int,int>;
const ll INF=1LL<<30;
const ll LINF=1LL<<61;
const double eps=1e-9;
const ll MOD=1000000007LL;
vector<ll> f,fi;
ll mpow(ll x,ll n){
ll res=1;
while(n>0){
if(n&1){
res=res*x%MOD;
}
x=x*x%MOD;
n>>=1;
}
return res;
}
ll ncr(ll n,ll r){
if(n<r)return 0;
if(r==0)return 1;
return f[n]*fi[r]%MOD*fi[n-r]%MOD;
}
int main(){
int n;cin>>n;
f.resize(n+10,0);
fi.resize(n+10,0);
f[0]=1;
for(ll i=1;i<=n;i++)f[i]=f[i-1]*i%MOD;
fi[n]=mpow(f[n],MOD-2LL);
for(ll i=n-1;i>=0;i--)fi[i]=fi[i+1]*(i+1)%MOD;
vector<vector<ll>> dp(n+10,vector<ll>(n+10,0));
int a,b,c,d;cin>>a>>b>>c>>d;
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];
dp[i][j]%=MOD;
ll s=1;
for(int k=1;k<c;k++)s=s*ncr(n-j+i*k,i)%MOD;
for(int k=c;k<=d;k++){
if(j-i*k<0)break;
s=s*ncr(n-j+i*k,i)%MOD;
dp[i][j]+=dp[i-1][j-i*k]*s%MOD*fi[k]%MOD;
dp[i][j]%=MOD;
}
}
}
cout<<dp[b][n]<<endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,k;
cin >> N >>k;
int sum;
if(k==1){
sum = N+1;
}
else if(k==2||k==3||k==4){
if (N==1){
sum = 2;
}
else{
sum = 4 + k*(N-2);
}
}
else if(k==5||k==6||k==7){
if (N==1){
sum = 2;
}
else if(N==2){
sum = 4;
}
else{
sum = 8 + k*(N-3);
}
}
else{
if (N==1){
sum = 2;
}
else if (N==2){
sum = 4;
}
else if (N==3){
sum = 8;
}
else{
sum = 16 + k*(N-4);
}
}
cout<<sum<<endl;
}
| #include <stdio.h>
int main() {
int n, k, number = 1;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
number = number * 2 < number + k ? number * 2 : number + k;
}
printf("%d\n", number);
return 0;
}
| 1 |
#include<bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for(int i=(l), i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
ll gcd(ll a,ll b){return b ? gcd(b,a%b) : a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
char alpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main(){
int a, b; cin >> a >> b;
if(a > 8 || b > 8){
cout << ":(" << endl;
}else{
cout << "Yay!" << endl;
}
} | # include <bits/stdc++.h>
# define sz(x) (int)((x).size())
# define F first
# define S second
# define pb push_back
# define ub upper_bound
# define lb lower_bound
# define all(x) x.begin(), x.end()
# define pqueue priority_queue
# define mset multiset
# define umap unordered_map
# define Speed() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
# define rep(i,n) for(int i=0;i<n;++i)
# define forn(i,n) for(int i=1;i<=n;++i)
# define lr(i,l,r) for(int i=l;(l>r?i>=r:i<=r);(l>r?--i:++i))
using namespace std;
template<class T> void umin(T &a,T b){a=min(a,b);}
template<class T> void umax(T &a,T b){a=max(a,b);}
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int dx[]={1,0,-1,0,-1,-1,1,1},dy[]={0,1,0,-1,-1,1,-1,1};
const int mod = 1e9+7;
const ll N = 1e5+4;
ll n,m;
void solve(){
vector<int>d;
cin>>n>>m;
for(int i=1;i*i<=m;++i){
if(m%i==0){
d.pb(i);
if(m/i!=i)d.pb(m/i);
}
}
sort(all(d));
reverse(all(d));
rep(i,sz(d)){
if(n*d[i]<=m){
cout<<d[i];
return;
}
}
}
int main(){
Speed();
int T=1;
//cin>>T;
while(T--)
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
constexpr int inf = 0x3f3f3f3f;
constexpr ll linf = 0x3f3f3f3f3f3f3f3fLL;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll k; cin >> k;
ll m = k % 50;
cout << 50 << '\n';
vector<ll> a(50, k / 50 + 49 - m);
for (int i = 0; i < m; i++) a[i] += 51;
for (int i = 0; i < 50; i++) cout << a[i] << " \n"[i == 49];
return 0;
}
| #include <cstdio>
#include <cstdint>
#include <vector>
#include <algorithm>
bool f(std::vector<intmax_t>& a) {
std::sort(a.rbegin(), a.rend());
intmax_t n = a.size();
a[0] -= n;
for (size_t i = 1; i < a.size(); ++i) ++a[i];
std::sort(a.begin(), a.end());
return !std::all_of(a.begin(), a.end(), [=](auto x) { return x < n; });
}
int main() {
intmax_t k;
scanf("%zu", &k);
size_t n = 50;
std::vector<intmax_t> a(n, n+(n+k-1)/n);
for (size_t i = 0; i < 50; ++i) f(a);
if (k % n != 0) {
size_t m = n - k%n;
for (size_t i = 0; i < m; ++i) f(a);
}
printf("%zu\n", n);
for (size_t i = 0; i < a.size(); ++i)
printf("%jd%c", a[i], i+1<a.size()? ' ': '\n');
}
| 1 |
/**
* author: souzai32
* created: 14.08.2020 14:10:05
**/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n,k;
cin >> n >> k;
vector<long long> x(n);
rep(i,n) cin >> x.at(i);
long long left,right;
long long ans=1e9;
rep(i,n-k+1){
left=x.at(i);
right=x.at(i+k-1);
ans=min(ans,min(abs(left)+abs(left-right),abs(right)+abs(left-right)));
// cout << left << ' ' << right << endl;
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long int
#define ld long double
#define ordered_set tree < ll , null_type , less<ll> , rb_tree_tag , tree_order_statistics_node_update >
//added two more functions to set
//(1)*(set.find_by_order(k))[kth element in the sorted set]
//(2)set.order_of_key(k)[count of elements strictly less than k]
typedef vector< int > vi;
typedef vector<long long> lvi;
typedef vector< vector<int> > vvi;
typedef vector< vector<long long> > lvvi;
typedef pair< int,int > ii;
typedef pair< long long,long long > lii;
typedef vector<pair<int,int>> vii;
typedef vector<pair<long long,long long>> lvii;
typedef vector<vector<pair<int,int>>> vvii;
typedef vector<vector<pair<long long,long long>>> lvvii;
typedef vector<bool> vb;
// #ifdef ONLINE_JUDGE
// #define endl '\n'
// #endif
#define pb push_back
#define all(c) (c).begin(),(c).end()
#define tr(c,i) for(auto i = (c).begin(); i != (c).end(); i++)//remember i is an iterator
#define tc(t) int (t); cin>>(t);while((t)--)
#define ff first
#define ss second
#ifdef ONLINE_JUDGE
#define error(args...) 0
#else
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#endif
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr <<"[ "<< *it << " = " << a << " ]"<< endl;
err(++it, args...);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
const long long mod = 1e9 + 7;
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
long long mos() { return 0LL; }
template<typename T, typename... Args>
T mos(T a, Args... args) { return ((a + mos(args...))%mod + mod)%mod; }
long long mop() { return 1LL; }
template<typename T, typename... Args>
T mop(T a, Args... args) { return (a*mop(args...))%mod; }
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,k;
cin>>n>>k;
vi a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
int k1=k;
while(k>0)
{
// vi b(n);
vi suffix(n+1,0);
for (int i = 0; i < n; ++i)
{
// for(int j=max(0,i-a[i]);j<=min(n-1,i+a[i]);j++)
// {
// b[j]++;
// }
int low = max(0,i-a[i]),high = 1+min(n-1,i+a[i]);
suffix[low]++;
suffix[high]--;
// error(i,low,high);
}
a[0]=suffix[0];
for(int i=1;i<n;i++)
{
suffix[i]+=suffix[i-1];
a[i]=suffix[i];
}
k--;
bool ok=true;
for (int i = 0; i < n; ++i)
{
// cout<<a[i]<<" ";
if(a[i]!=n) ok=false;
}
// cout<<endl;
if(ok) break;
}
// cout<<"steps: "<<k1-k<<endl;
for (int i = 0; i < n; ++i)
{
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
// WA
// 1. overflow
// 2. re-initialize global variables for every test case.
// 3. edge cases like n=1
// Run time error
// 1. division by zero.
// 2. array bounds.
// TLE
// 1. uncomment that #define endl '\n' line | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e16
#define mod 1000000007
map<ll,ll> cnt[2];
ll D;
ll dfs(const vector<ll>& a,ll i,ll sum){
// if(sum>D*1000||sum<-D*1000)return 0;
ll n=a.size();
if(i==n){
if(sum==D) return 1;
else return 0;
}else{
ll res=0;
bool done=false;
repl(c,-9,9+1){
if(sum+c*a[i]>D){
res+=dfs(a,i+1,sum+(c-1)*a[i])*cnt[(i!=0?0:1)][c-1];
res+=dfs(a,i+1,sum+c*a[i])*cnt[(i!=0?0:1)][c];
done=true;
break;
}
}
if(!done){
res+=dfs(a,i+1,sum+9*a[i])*cnt[(i!=0?0:1)][9];
}
return res;
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
rep(a,10)rep(b,10){
cnt[0][b-a]++;
if(a>0)cnt[1][b-a]++;
}
cin>>D;
ll res=0;
rep(d,18){
vector<ll> ds;
rep(i,d/2+1){
ll p1=pow(10,i);
ll p2=pow(10,d-i);
ll dif=p2-p1;
ds.push_back(dif);
}
ll t=1;
if(ds.back()==0){
t*=10; ds.pop_back();
}
res+=dfs(ds,0,0)*t;
}
cout<<res<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (long long i = (long long)(0); i < (long long)(n); ++i)
#define reps(i, n) for (long long i = (long long)(1); i <= (long long)(n); ++i)
#define rrep(i, n) for (long long i = ((long long)(n)-1); i >= 0; i--)
#define rreps(i, n) for (long long i = ((long long)(n)); i > 0; i--)
#define irep(i, m, n) for (long long i = (long long)(m); i < (long long)(n); ++i)
#define ireps(i, m, n) for (long long i = (long long)(m); i <= (long long)(n); ++i)
#define SORT(v, n) sort(v, v + n);
#define REVERSE(v, n) reverse(v, v+n);
#define vsort(v) sort(v.begin(), v.end());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
#define replace_all(s, b, a) replace(s.begin(),s.end(), b, a);
#define PI (acos(-1))
#define FILL(v, n, x) fill(v, v + n, x);
#define sz(x) long long(x.size())
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vs = vector<string>;
using vpll = vector<pair<ll, ll>>;
using vtp = vector<tuple<ll,ll,ll>>;
using vb = vector<bool>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e9+10;
const ll MOD = 1e9+7;
const ll LINF = 1e18;
ll n,m,v,p;
vll a;
vll sum;
// mid ... 添え字 => a[mid]は採用されるか
// midが採用される
// midがp以内である(n-mid+<=p) => ok
// midがpより後である =>
// midを+1, 0~mid-1を+1する。残り v-(mid+1)
// midがp番目になるには2つ条件が必要
// - v-(mid+1)<=p-1
// - a[mid]+m>=a[n-p (p番目)]
bool isOk(ll mid){
if(n-mid<=p) return 1;
ll rem=v-(mid+1)-(p-1); // midを選ぶ上で1人が影響のない分を投票した残り
if(rem<=0){
if(a[mid]+m>=a[n-p]) return 1;
}else{
ll cnt=(n-(p-1))-(mid+1);
ll d=(sum[n-(p-1)]-sum[mid+1]);
ll x=(a[mid]+m)*cnt-d;
// cout<<mid<<' '<<d<<' '<<x<<' '<<rem<<' '<<cnt<<endl;
if(x>=rem*m && a[mid]+m>=a[n-p]) return 1;
}
return 0;
}
signed main()
{
cin.tie( 0 ); ios::sync_with_stdio( false );
cin>>n>>m>>v>>p;
a.resize(n);
rep(i,n) cin>>a[i];
vsort(a);
sum.resize(n+1);
rep(i,n) sum[i+1]=sum[i]+a[i];
// rep(i,n) cout<<a[i]<<' ';
// cout<<endl;
ll ng=-1, ok=n-1;
while(abs(ok-ng)>1){
ll mid=(ok+ng)/2;
if(isOk(mid)) ok=mid;
else ng=mid;
}
ll ans=n-ok;
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
typedef long long ll;
#define pb push_back
using namespace std;
typedef pair<ll,ll> pll;
vector< pll > v;
ll n;
ll h[5005], p[5005];
ll dp[5005][5005];
const ll inf = 1e16;
int main()
{
cin >> n;
v.pb(make_pair(-2LL , -2LL));
for(ll i=1;i<=n;i++) {
cin >> h[i] >> p[i];
v.pb(make_pair(h[i]+p[i], i));
}
sort(v.begin(), v.end());
for(ll i=1;i<=n;i++) dp[0][i] = inf;
dp[0][0] = 0;
for(ll i=1;i<=n;i++) {
ll id = v[i].second;
for(ll j = 0; j <= n; j++) {
dp[i][j] = dp[i-1][j];
if(j && dp[i-1][j-1] <= h[id]) dp[i][j] = min(dp[i][j], p[id] + dp[i-1][j-1]);
}
}
for(ll i=n;i>=0;i--){
if(dp[n][i] != inf) {
cout << i << endl; return 0;
}
}
return 0;
}
| #include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
typedef std::pair<int, int> P;
bool is_vis[1003][1003];
bool is_fin[1003][1003];
bool is_cycle;
void dfs(map<P, vector<P>> &g, P p) {
int player1 = p.first;
int player2 = p.second;
is_vis[player1][player2] = true;
for (int i = 0; i < (int)g[p].size(); i++) {
P nxt = g[p][i];
int nxt_player1 = nxt.first;
int nxt_player2 = nxt.second;
if (is_fin[nxt_player1][nxt_player2]) {
continue;
}
if (is_vis[nxt_player1][nxt_player2] && !is_fin[nxt_player1][nxt_player2]) {
is_cycle = true;
return;
}
dfs(g, nxt);
}
is_fin[player1][player2] = true;
}
int dp[1003][1003];
int rec(map<P, vector<P>> &g, P p) {
int player1 = p.first;
int player2 = p.second;
if (dp[player1][player2] != -1) {
return dp[player1][player2];
}
int res = 0;
for (int i = 0; i < (int)g[p].size(); i++) {
res = max(res, rec(g, g[p][i]) + 1);
}
return dp[player1][player2] = res;
}
int main() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
int n;
cin >> n;
map<P, vector<P>> g;
vector<vector<int>> A(n, vector<int>(n - 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - 1; j++) {
cin >> A[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j < n - 1; j++) {
int pre_1 = i + 1, pre_2 = A[i][j - 1];
if (pre_1 > pre_2) {
swap(pre_1, pre_2);
}
int nxt_1 = i + 1, nxt_2 = A[i][j];
if (nxt_1 > nxt_2) {
swap(nxt_1, nxt_2);
}
g[make_pair(pre_1, pre_2)].push_back(make_pair(nxt_1, nxt_2));
}
}
// 閉路検出の処理
// https://qiita.com/drken/items/a803d4fc4a727e02f7ba#4-6-サイクル検出
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i >= j) {
continue;
}
if (g.find(make_pair(i, j)) == g.end()) {
continue;
}
if (is_vis[i][j]) {
continue;
}
is_cycle = false;
dfs(g, make_pair(i, j));
if (is_cycle) {
cout << -1 << "\n";
return 0;
}
}
}
for (int i = 0; i < 1003; i++) {
for (int j = 0; j < 1003; j++) {
dp[i][j] = -1;
}
}
// 最長経路を求める
// EDPC (https://atcoder.jp/contests/dp/tasks/dp_g) で見た
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i >= j) {
continue;
}
ans = max(ans, rec(g, make_pair(i, j)) + 1);
}
}
cout << ans << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
using PP = pair<int,pair<int,int>>;
using T = tuple<string,int,int>;
const ll INF = 1LL<<60;
int main(){
vector<int> a(3);
rep(i,3) cin >> a[i];
int k; cin >> k;
sort(a.begin(), a.end());
for(int i = 0; i < k; i++){
a[2] *= 2;
}
int ans = 0;
rep(i,3) ans += a[i];
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <bitset>
#include <utility>
#include <numeric>
#include <queue>
#include <stack>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9 + 7);
int main(void) {
int a, b, c, k;
cin >> a >> b >> c >> k;
vector<int> x = {a, b, c};
int ans = 0;
for(int i = 0; i < k; ++i) {
sort(x.begin(), x.end());
x[2] *= 2;
}
cout << accumulate(x.begin(), x.end(), 0) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <vector>
#define rep(i, n) for(int i = 0; i < n; ++i)
#define ll long long
using namespace std;
bool check(string x, string y) {
int a = x.size()-1;
return x[a] == y[0];
}
int main() {
string a, b, c;
cin >> a >> b >> c;
if(check(a, b) && check(b, c)) cout << "YES" << endl;
else cout << "NO" << endl;
return 0;
}
| #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;
bool check = 0;
string s;
int N = 3;
vector<int> v(N);
int a, b;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
int main()
{
int c, d, x, y;
cin >> a >> b >> c >> d;
x = a + b;
y = c + d;
if (x < y)
pr("Right");
else if (x > y)
pr("Left");
else
pr("Balanced");
return 0;
} | 0 |
/******************************************
* AUTHOR : GURUTEJA *
******************************************/
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define N 100005
#define MOD 1000000007
#define dd double
#define rep(i, n) for(int i = 0; i < n; i++)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep1(i,b) for(int i=1;i<=b;i++)
#define pb push_back
#define mp make_pair
#define clr(x) x.clear()
#define sz(x) ((int)(x).size())
#define F first
#define S second
void debug(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int main() {
debug();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s,s1;
cin>>s;
int x=1e9;
for (int i = 0; i<s.length(); ++i)
{
if(i<s.length()-2){
s1+=s[i],s1+=s[i+1],s1+=s[i+2];
x=min(x,abs(753-stoi(s1)));
}
s1.clear();
}
cout<<x<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define DISP1(as) for(auto it : as) cout<<it.f<<" "<<it.s<<") ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"///REACHED///\n";
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 2e+5 + 99;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9 + 7;
// <------------- Declare Variables Here ------------> //
ll T = 1;
ll n, k, l, q, x;
string s;
ll a[600],c[505];
vpll b;
vll res;
// < ----------- func eh ---------------- ? //
// <------------- Start of main() -------------------> //
void MAIN() {
cin>>s;
ll mini = INF;
for(ll i=0;i<s.length()-2;i++) {
mini = min(mini , abs(stoll(s.substr(i,3)) - 753));
}
cout<<mini;
}
int main() {
fastio; randomINT;
//cin >> T;
while (T--) {
MAIN();
}
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
class BIT{
public:
int size;
int* bit;
BIT(int _size = 0){
size = _size;
bit = new int[size];
for(int i = 0; i < size; i++) bit[i] = 0;
}
~BIT(){delete[] bit;}
/*
En: returns sum of [from bit[0] to bit[i]].
Ja: bit[0]からbit[i]までの合計をかえす。
*/
int sum(int i){
int s = 0;
while(i > 0){
s += bit[i];
i -= i&-i;
}
return s;
}
/*
En: add x at bit[i].
Ja: bit[i]にxを加える。
*/
void add(int i, int x){
while(i<size){
bit[i] += x;
i += i&-i;
}
}
};
vector<int> make(const vector<int> v){
vector<int> tmp = v;
sort(tmp.begin(), tmp.end());
int cnt = 1;
map<int,int> M;
for(int i = 0; i < (int)tmp.size(); i++){
if(M.count(tmp[i])) continue;
M[tmp[i]] = cnt++;
}
vector<int> vec(v.size());
for(int i = 0; i < (int)v.size(); i++) vec[i] = M[v[i]];
return vec;
}
int main(){
int n;
cin >> n;
vector<int> v(n);
for(int i = 0; i < n; i++) cin >> v[i];
v = make(v);
BIT bit(n+1);
long long ans = 0;
for(int i = 0; i < n; i++){
ans += i - bit.sum(v[i]);
bit.add(v[i],1);
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <cstdio>
using namespace std;
typedef long long ll;
ll /*A[2000000],*/ cnt = 0;
int A[210000];
int L[110001];
int R[110001];
int merge(int l, int m, int r){
int n1 = m - l, n2 = r - m, i, j;
//ll L[n1 + 1], R[n2 + 1];
for(i = 0;i < n1;i++)L[i] = A[i + l];
for(i = 0;i < n2;i++)R[i] = A[i + m];
i = j = 0;
for(int k = 0;k < r - l;k++){
if(j == n2 || (i < n1 && L[i] <= R[j]))A[k + l] = L[i++];
else A[k + l] = R[j++], cnt += n1 - i;
}
}
int mergeSort(int l, int r){
if(l + 1 < r){
int m = (l + r) / 2;
mergeSort(l, m);
mergeSort(m, r);
merge(l, m, r);
}
}
int main(){
int n;
scanf("%d", &n);
for(int i = 0;i < n;i++)scanf("%d", &A[i]);
mergeSort(0, n);
printf("%lld\n", cnt);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define INF 5000000000000000000
#define ll long long
#define pll pair<ll, ll>
using namespace std;
ll N, M;
ll count_max(vector<queue<ll>>& A, vector<bool>& already)
{
vector<ll> cnt(M, 0);
for (ll i = 0; i < N; ++i) {
while (true) {
if (already.at(A.at(i).front())) {
A.at(i).pop();
}
else {
cnt.at(A.at(i).front()) += 1;
break;
}
}
}
ll res = 0, index;
for (ll i = 0; i < M; ++i) {
if (res < cnt.at(i)) {
index = i;
res = cnt.at(i);
}
}
already.at(index) = true;
return res;
}
int main()
{
cin >> N >> M;
ll ans = INF;
vector<bool> already(M, false);
vector<queue<ll>> A(N);
for (ll i = 0; i < N; ++i) {
for (ll j = 0; j < M; ++j) {
ll a;
cin >> a;
a -= 1;
A.at(i).push(a);
}
}
for (ll i = 0; i < M; ++i) {
ans = min(ans, count_max(A, already));
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using P = pair<string,int>;
const double PI = acos(-1);
int main() {
int l,m,n;
cin >> l >> m >> n;
vector<int> a(l);
vector<int> b(m);
rep(i,l) cin >> a.at(i);
rep(i,m) cin >> b.at(i);
vector<vector<int>> x(n,vector<int>(3));
rep(i,n)rep(j,3) cin >> x.at(i).at(j);
int ans = 100000000000000000;
int t;
rep(i,n){
t = a.at(x.at(i).at(0)-1)+b.at(x.at(i).at(1)-1)-x.at(i).at(2);
ans = min(ans,t);
}
sort(a.begin(),a.end());
sort(b.begin(),b.end());
if(a.at(0)+b.at(0) < ans) ans = a.at(0)+b.at(0);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define all(v) v.begin(), v.end()
#define inputv(v, n) \
vl v; \
rep(i, n) { \
ll x; \
cin >> x; \
v.push_back(x); \
}
bool chmin(ll& a, ll b) { if (b < a) { a = b; return 1; } return 0; }
bool chmax(ll& a, ll b) { if (b > a) { a = b; return 1; } return 0; }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N = 500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans;
struct Gragh {
ll N;
vector<vl> G;
vl visited;
Gragh(ll n) {
N = n;
G.resize(N);
resetv();
}
void add(ll a, ll b) { G[a].push_back(b); }
void resetv(void) { visited = vl(N, 0); }
//重さ無し
void dfs(ll x) {
visited[x] = 1;
for (ll i : G[x]) {
if (visited[i] == 0) {
dfs(i);
}
}
}
};
int main() {
cin >> n >> m;
Gragh G(2 * n);
rep(i, m) {
cin >> a >> b;
a--;
b--;
G.add(a * 2, b * 2 + 1);
G.add(b * 2, a * 2 + 1);
G.add(a * 2+1, b * 2);
G.add(b * 2+1, a * 2);
}
G.dfs(0);
vl dp(2, 0);
rep(i, n * 2) {
if (G.visited[i] == 1)dp[i % 2]++;
}
x=dp[0];
y=dp[1];
k=x+y-n;
ans=k*(n-k)+k*(k-1)/2+(x-k)*(y-k)-m;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
const ld EPS = 1e-10;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};
const int MAX_V = 100000;
vector<int> es[MAX_V];
vector<int> col(MAX_V, -1);
bool loop = false;
void dfs(int now, int c){
col[now] = c;
for(auto &e: es[now]){
if(col[e] == -1) dfs(e, c^1);
if(col[e] == c) loop = true;
}
}
int main(){
ll N, M;
cin >> N >> M;
rep(i, M){
int u, v; cin >> u >> v; u--, v--;
es[u].pb(v), es[v].pb(u);
}
dfs(0, 0);
if(loop) cout << N*(N-1)/2-M << endl;
else{
ll a = 0, b = 0;
rep(i, N) (col[i]? a : b)++;
cout << a*b-M << endl;
}
} | 1 |
#include "bits/stdc++.h"
#define int long long
using namespace std;
const int mod = 1e9 + 7;
int32_t main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<vector<int>> a(n, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
vector<int> score(1 << n);
for (int mask = 0; mask < (1 << n); mask++) {
for (int i = 0; i < n; i++) {
if ((mask & (1 << i)) == 0) {
continue;
}
for (int j = 0; j < i; j++) {
if ((mask & (1 << j)) == 0) {
continue;
}
score[mask] += a[i][j];
}
}
}
vector<int> dp(1 << n, 0);
for (int mask = 1; mask < (1 << n); mask++) {
for (int submask = mask; submask > 0; submask--, submask &= mask) {
dp[mask] = max(dp[mask], score[submask] + dp[mask ^ submask]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
| #include<string>
#include<iostream>
#include<cctype>
#include<cmath>
#include<cstdio>
using namespace std;
int main(void){
int a;
cin >> a;
int b[10000];
long long min=pow(10,6);
long long max=-pow(10,6);
int i;
for(i=0;i<a;i++){
cin >> b[i];
}
for(i=0;i<a;i++){
if(min>b[i]) min=b[i];
if(max<b[i]) max=b[i];
}
long long sum=0;
for(i=0;i<a;i++){
sum+=b[i];
}
cout << min << " "<< max << " "<< sum <<endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<cstdio>
using namespace std;
#define ll long long
#define rep(i, n) for(int i = 0; i < n; i++)
#define P pair<int, int>
typedef vector<int> vec;
typedef vector<vec> mat;
int main(){
int n, K;
cin >> n >> K;
int v[n];
rep(i, n) cin >> v[i];
int mx = min(n, K);
int ans = 0;
for (int i = 0; i <= mx; i++){
for (int j = 0; j <= i; j++){
vec v_s;
for (int k = 0; k < j; k++){
v_s.push_back(v[k]);
}
for (int k = n - 1; k > (n - 1) - (i - j); k--){
v_s.push_back(v[k]);
}
sort(v_s.begin(), v_s.end());
// for (int k = 0; k < v_s.size(); k++){
// cout << v_s[k] << " ";
// }cout << endl;
int sm = 0;
rep(k, v_s.size()){
if(k < K - i && v_s[k] < 0) continue;
sm += v_s[k];
}
// cout << sm << endl;
ans = max(sm, ans);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define pr(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#define all(v) (v).begin(), (v).end()
#define int long long
#define sz(v) (int)(v).size()
#define mod 1000000007 // ((a- b)% mod+ mod)% mod
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
const int N= 51;
const int M= 101;
int dp[N][N][M];
void solve() {
int n, k; cin >> n>> k;
memset(dp, -1, sizeof(dp));
vector<int> v(n);
for (auto& i: v) cin >> i;
function<int(int, int, int)> calc= [&](int i, int j, int cnt)->int {
if (cnt< 0) return -1e18;
if (cnt== 0) return 0;
if (i> j) return 0;
int &ret= dp[i][j][cnt];
if (ret!= -1) return ret;
ret= 0;
ret= max(ret, calc(i+ 1, j, cnt- 1)+ v[i]);
ret= max(ret, calc(i+ 1, j, cnt- 2));
ret= max(ret, calc(i, j- 1, cnt- 1)+ v[j]);
ret= max(ret, calc(i, j- 1, cnt- 2));
return ret;
};
cout << calc(0, n- 1, k)<< "\n";
}
int32_t main(){
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int T= 1;
//cin >> T;
while ( T-- ) {
solve();
}
return 0;
}
| 1 |
#include <stdio.h>
int main(){
int dice[7];
char com[1000];
int i,j,k;
int n,e,w,s,top;
for(i=1;i<=6;i++) scanf("%d",&dice[i]);
scanf("%s",com);
top=1;
n=5;
s=2;
w=4;
e=3;
for(i=0;com[i]!='\0';i++){
if(com[i]=='N'){
n=top;
top=s;
s=7-n;
}else if(com[i]=='S'){
s=top;
top=n;
n=7-s;
} else if(com[i]=='W'){
w=top;
top=e;
e=7-w;
}else if(com[i]=='E'){
e=top;
top=w;
w=7-e;
}
}
printf("%d\n",dice[top]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin >> s;
map<char,vector<int>> dist;
for(int i=0; i< s.size(); i++){
dist[s.at(i)].push_back(i);
}
/*ここからアンバランス探しmapにはアルファベットと出現箇所が紐づけ
各アルファベットについて、隣り合ってたらok
*/
bool seikai = false;
for(auto& a: dist ){
if(a.second.size()>1){
for(int i=0; i< a.second.size() - 1; i++ ){
if((a.second[i+1] - a.second[i] ==1) ||
(a.second[i+1] - a.second[i]==2)){
cout << a.second[i] +1<< " " << a.second[i+1] +1;
seikai = true;
goto Finish;
}
}
}
}
Finish:
if(!seikai){cout << -1 << " " << -1;}
cout << endl;
}
| 0 |
/*
bfs 找环
*/
#include <bits/stdc++.h>
#define N 1005
#define M 2005
using namespace std;
int n, m;
int dep[N];
int head[N], nex[M], to[M], e;
int stk[N], top;
bool instack[N], vis[N], G[N][N];
vector<int> res;
inline int Rd() {
int x = 0; char ch = getchar();
while(!isdigit(ch)) ch = getchar();
while(isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
inline void Ae(int u, int v) {
nex[++e] = head[u], head[u] = e;
to[e] = v;
}
void calc(int u, int v) {
do {
res.push_back(stk[top]);
} while(stk[top--] != v);
int ans = res.size();
printf("%d\n", ans);
for(int i = 0; i < ans; ++i) printf("%d\n", res[i]);
exit(0);
}
void dfs(int u) {
stk[++top] = u;
instack[u] = vis[u] = true;
for(int i = head[u]; i; i = nex[i]) {
int v = to[i];
if(vis[v]) {
if(instack[v]) calc(u, v);
} else {
dfs(v);
}
}
instack[u] = false, --top;
return;
}
int main() {
n = Rd(), m = Rd();
for(int i = 1; i <= m; ++i) {
int u = Rd(), v = Rd();
G[u][v] = true;
Ae(u, v);
}
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= n; ++j) {
if(G[i][j] && G[j][i]) {
puts("2");
printf("%d\n%d\n", i, j);
return 0;
}
}
}
for(int i = 1; i <= n; ++i)
if(!vis[i])
dfs(i);
puts("-1");
return 0;
} | #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>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
#define rp(i, k, n) for (int i = k; i < n; i++)
using ll = long long;
using ld = double;
template<class T>inline bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>inline bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7ll;
const double PI=3.14159265358979323846;
int main() {
int h, w, k;
cin >> h >> w >> k;
// dp[i][j]...i列目が終わった時にj行目にいるようなあみだくじの作り方
vector<vector<ll>> dp(h+10, vector<ll>(w+10));
vector<ll> com(w+10);
com[0] = 1ll;
com[1] = 2ll;
rp(i, 2, w){
com[i] = com[i-1] + com[i-2];
com[i] %= MOD;
}
dp[0][1] = 1ll;
rp(i, 0, h) {
rp(j, 1, w+1) {
if(j < w) {
int right = max(0, w-j-2);
int left = max(0, j-2);
dp[i+1][j+1] += dp[i][j] * com[right] * com[left] % MOD; dp[i+1][j+1] %= MOD;
}
if(j > 1) {
int right = max(0, w-j-1);
int left = max(0, j-3);
dp[i+1][j-1] += dp[i][j] * com[right] * com[left] % MOD; dp[i+1][j-1] %= MOD;
}
int right = max(0, w-j-1);
int left = max(0, j-2);
dp[i+1][j] += dp[i][j] * com[right] * com[left] % MOD; dp[i+1][j] %= MOD;
}
}
// rp(i, 0, h) {
// rp(j, 1, w+1) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
cout << dp[h][k] << endl;
return 0;
}
| #pragma GCC optimize(3 , "Ofast" , "inline")
#include <bits/stdc++.h>
#define rep(i , a , b) for(register int i=(a);i<=(b);i++)
#define per(i , a , b) for(register int i=(a);i>=(b);i--)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int , int> pi;
template<class T>
inline void read (T &x) {
x = 0;
int sign = 1;
char c = getchar ();
while (c < '0' || c > '9') {
if ( c == '-' ) sign = - 1;
c = getchar ();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar ();
}
x = x * sign;
}
const int maxn = 2e5 + 10;
const int inf = int (1e9);
const ll INF = ll (1e18);
const double PI = acos (- 1);
const int mod = 1e9+7;
const double eps = 1e-8;
ll dp[111][10];
int main () {
int h,w,m;
read (h);read (w);read (m);
if(w==1) {
puts ("1");
return 0;
}
dp[0][0]=1;
rep (i,1,h) {
rep (j,0,(1<<w-1)-1) {
bool ok=1;
rep (k,0,w-3) {
if((j&(1<<k))&&(j&(1<<k+1))) {
ok=0;
break;
}
}
if(!ok) continue;
rep (k,0,w-1) {
if(k>=1&&(j&(1<<(k-1)))) {
dp[i][k]=(dp[i][k]+dp[i-1][k-1])%mod;
}
else if(k<w-1&&(j&(1<<k))) {
dp[i][k]=(dp[i][k]+dp[i-1][k+1])%mod;
}
else dp[i][k]=(dp[i][k]+dp[i-1][k])%mod;
}
}
}
cout<<dp[h][m-1]<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
vector<ll> calc_divisor(ll n) {
vector<ll> res;
for (ll i = 1LL; i*i <= n; ++i) {
if (n % i == 0) {
res.push_back(i);
ll j = n / i;
if (j != i) res.push_back(j);
}
}
sort(res.begin(), res.end());
return res;
}
ll N, M;
int main() {
cin >> N >> M;
vector<ll> v = calc_divisor(M);
reverse(v.begin(), v.end());
ll ans = 0;
rep(i, v.size()) {
// cout << v[i] << endl;
if (M % v[i] == 0) {
ll tmp = M / v[i];
if (tmp >= N) {
ans = v[i];
break;
}
}
}
cout << ans << endl;
} | #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, M; cin >> N >> M;
int MAX = M/N;
for (int i=MAX;i>=1;i--){
if ((M - i*N)%i==0) {
cout << i << endl;
return 0;
}
}
// cout << fixed << setprecision(10);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
struct Node
{
int first , second;
int dir;
}node[maxn];
// x + y
bool cmp1(const Node & a , const Node & b)
{
if (a.first + a.second != b.first + b.second)
return a.first + a.second < b.first + b.second;
return a.first < b.first;
}
// x - y
bool cmp2(const Node & a , const Node & b)
{
if (a.first - a.second != b.first - b.second)
return a.first - a.second < b.first - b.second;
return a.first < b.first;
}
// x
bool cmp3(const Node & a , const Node & b)
{
if (a.first!= b.first)
return a.first < b.first;
return a.second < b.second;
}
// y
bool cmp4(const Node & a , const Node & b)
{
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
int check (char g)
{
if (g == 'U') return 0;
if (g == 'D') return 1;
if (g == 'R') return 2;
return 3;
}
int main()
{
ios::sync_with_stdio(false);
int n ; cin >> n;
for (int i = 1 ; i <= n ; i++){
cin >> node[i].first >> node[i].second;
char g;
cin >> g;
node[i].dir = check(g);
}
int ans = 1e9;
node[0].first = node[0].second = -1;
int pos , pos2;
sort(node + 1 , node + 1 + n , cmp1);
for (int i = 1 ; i <= n ; i++){
if (node[i].first + node[i].second != node[i - 1].first + node[i - 1].second){
pos = pos2 = -1;
}
if (node[i].dir == check('U')){
if (pos != -1)
ans = min (ans , abs(node[i].first - node[pos].first) * 10);
}
if (node[i].dir == check('R')){
pos = i;
}
if (node[i].dir == check('L')){
if (pos2 != -1)
ans = min (ans , abs(node[i].first - node[pos2].first) * 10);
}
if (node[i].dir == check('D')){
pos2 = i;
}
}
sort(node + 1 , node + 1 + n , cmp2);
for (int i = 1 ; i <= n ; i++){
if (node[i].first - node[i].second != node[i - 1].first - node[i - 1].second){
pos = pos2 = -1;
}
if (node[i].dir == check('L')){
if (pos != -1)
ans = min (ans , abs(node[i].first - node[pos].first) * 10);
}
if (node[i].dir == check('U')){
pos = i;
}
if (node[i].dir == check('D')){
if (pos2 != -1)
ans = min (ans , abs(node[i].first - node[pos2].first) * 10);
}
if (node[i].dir == check('R')){
pos2 = i;
}
}
sort(node + 1 , node + 1 + n , cmp3);
for (int i = 1 ; i <= n ; i++){
if (node[i].first != node[i - 1].first){
pos = -1;
}
if (node[i].dir == check('D')){
if (pos != -1)
ans = min (ans , abs(node[i].second - node[pos].second) * 5);
}
else if (node[i].dir == check('U')){
pos = i;
}
}
sort(node + 1 , node + 1 + n , cmp4);
for (int i = 1 ; i <= n ; i++){
if (node[i].second != node[i - 1].second){
pos = -1;
}
if (node[i].dir == check('L')){
if (pos != -1)
ans = min (ans , abs(node[i].first - node[pos].first) * 5);
}
else if (node[i].dir == check('R')){
pos = i;
}
}
if (ans == 1e9) cout << "SAFE" << endl;
else cout << ans << endl;
return 0;
}
| #include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
#include<set>
#define l(x) (x<<1)
#define r(x) ((x<<1)|1)
#define IL inline
#define reg register
#define LL long long
#define N 200010
#define INF 0x3f3f3f3f
using namespace std;
int n,i,j;
int ans=INF;
set <int> S[N*4];
struct Data{
int x,y;
char c;
}a[N];
IL int Abs(int x){return (x<0)?-x:x;}
IL void Swap(int &a,int &b){a^=b^=a^=b;}
IL int Min(int a,int b){return (a<b)?a:b;}
IL int Max(int a,int b){return (a>b)?a:b;}
IL int read(){
int p=0,f=1; char c=getchar();
while (c<48||c>57) {if (c=='-') f=-1; c=getchar();}
while (c>=48&&c<=57) p=(p<<1)+(p<<3)+c-48,c=getchar();
return p*f;
}
int main(){
#ifdef __Marvolo
freopen("zht.in","r",stdin);
freopen("zht.out","w",stdout);
#endif
n=read();
for (i=1;i<=n;i++){
a[i].x=read(); a[i].y=read(); a[i].c=getchar();
}
if (n==1){
puts("SAFE");
return 0;
}
for (i=1;i<=n;i++)
if (a[i].c=='U') S[a[i].x+a[i].y].insert(a[i].x);
for (i=1;i<=n;i++){
if (a[i].c=='R'){
if (!S[a[i].x+a[i].y].size()) continue;
j=*(--S[a[i].x+a[i].y].end());
if (j<a[i].x) continue;
j=*S[a[i].x+a[i].y].upper_bound(a[i].x);
ans=Min(ans,j-a[i].x);
}
}
for (i=0;i<4*N;i++) S[i].clear();
//U--R
for (i=1;i<=n;i++)
if (a[i].c=='D') S[a[i].x+a[i].y].insert(a[i].x);
for (i=1;i<=n;i++){
if (a[i].c=='L'){
if (!S[a[i].x+a[i].y].size()) continue;
j=*S[a[i].x+a[i].y].begin();
if (j>a[i].x) continue;
j=*(--S[a[i].x+a[i].y].upper_bound(a[i].x));
ans=Min(ans,a[i].x-j);
}
}
for (i=0;i<4*N;i++) S[i].clear();
//D--L
for (i=1;i<=n;i++)
if (a[i].c=='R') S[a[i].y-a[i].x+N].insert(a[i].x);
for (i=1;i<=n;i++){
if (a[i].c=='D'){
if (!S[a[i].y-a[i].x+N].size()) continue;
j=*S[a[i].y-a[i].x+N].begin();
if (j>a[i].x) continue;
j=*(--S[a[i].y-a[i].x+N].upper_bound(a[i].x));
ans=Min(ans,a[i].x-j);
}
}
for (i=0;i<4*N;i++) S[i].clear();
//D--R
for (i=1;i<=n;i++)
if (a[i].c=='L') S[a[i].y-a[i].x+N].insert(a[i].x);
for (i=1;i<=n;i++){
if (a[i].c=='U'){
if (!S[a[i].y-a[i].x+N].size()) continue;
j=*(--S[a[i].y-a[i].x+N].end());
if (j<a[i].x) continue;
j=*S[a[i].y-a[i].x+N].upper_bound(a[i].x);
ans=Min(ans,j-a[i].x);
}
}
for (i=0;i<4*N;i++) S[i].clear();
//D--R
if (ans!=INF) ans*=2;
for (i=1;i<=n;i++)
if (a[i].c=='R') S[a[i].y].insert(a[i].x);
for (i=1;i<=n;i++){
if (a[i].c=='L'){
if (!S[a[i].y].size()) continue;
j=*S[a[i].y].begin();
if (j>a[i].x) continue;
j=*(--S[a[i].y].upper_bound(a[i].x));
ans=Min(ans,a[i].x-j);
}
}
for (i=0;i<4*N;i++) S[i].clear();
//L--R
for (i=1;i<=n;i++)
if (a[i].c=='U') S[a[i].x].insert(a[i].y);
for (i=1;i<=n;i++){
if (a[i].c=='D'){
if (!S[a[i].x].size()) continue;
j=*S[a[i].x].begin();
if (j>a[i].y) continue;
j=*(--S[a[i].x].upper_bound(a[i].y));
ans=Min(ans,a[i].y-j);
}
}
for (i=0;i<4*N;i++) S[i].clear();
//U--D
if (ans==INF) puts("SAFE");
else cout<<ans*5<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define f first
#define s second
#define pb push_back
typedef vector<int> vi;
#define mod 1000000007
#define nos ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
int dp[3005][3005];
int n,t;
int happy(vector<pair<int,int>>&a,int pidx,int time)
{
if(time>=t||pidx>=n)
return 0;
if(dp[pidx][time]!=-1)
return dp[pidx][time];
return dp[pidx][time]=max(a[pidx].s+happy(a,pidx+1,time+a[pidx].f),happy(a,pidx+1,time));
}
int32_t main() {
nos;
cin>>n>>t;
vector<pair<int,int>>a(n);
for(int i=0;i<n;i++)
cin>>a[i].f>>a[i].s;
sort(a.begin(),a.end());
memset(dp,-1,sizeof(dp));
cout<<max(a[0].s+happy(a,1,a[0].f),happy(a,1,0));
return 0;
}
| #include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
#define repo(i, n) for(int i=1; i<=n; i++)
#define INF 1001001001
#define INFll 100100100100100
// debug用
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
using namespace std;
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;
int dp[3005][3005];
int main(){
int n, t;
cin >> n >> t;
vector<int> a(n);
vector<int> b(n);
vector<P> ab(n);
rep(i, n){
cin >> a[i] >> b[i];
ab[i]=P(a[i], b[i]);
}
sort(ab.begin(), ab.end());
rep(i, n){
a[i]=ab[i].first;
b[i]=ab[i].second;
}
rep(i, n){
rep(j, t){
if(j-a[i]<0){
dp[i+1][j]=dp[i][j];
} else {
dp[i+1][j]=max(dp[i][j], dp[i][j-a[i]]+b[i]);
}
}
}
int ans=0;
rep(i, n){
ans=max(dp[i][t-1]+b[i], ans);
}
cout << ans << endl;
return 0;
}
| 1 |
#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>;
const int INF = 1e9;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
#define PI 3.14159265358979323846264338327950L
#define MOD 1000000007
//setprecision(15)
int main() {
int A, B; cin >> A >> B;
if (B == 1) {
cout << "0" << endl; return 0;
}
if (B - A <= 0) {
cout << "1" << endl; return 0;
}
B -= A;
int cnt = 1;
while (1) {
cnt++;
if (B - (A - 1) <= 0) {
cout << cnt << endl;
return 0;
} else {
B -= A - 1;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define reps(i, n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
#define rrep(i, n) for(int i=((int)(n)-1); i>=0; --i)
#define rreps(i, n) for(int i=((int)(n)); i>0; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define pl(s) cout << (s) << "\n";
#define pls(...) {bool space = false; for(auto i : __VA_ARGS__) (cout << (space?" ":"") << i), space = true; cout << "\n";}
#define plexit(s) {cout << (s) << "\n"; exit(0);}
#define yes(s) cout << ((s)?"Yes":"No") << "\n";
template<typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using ll = long long; using ull = unsigned long long; using ld = long double;
template<typename T = int> using V = vector<T>; template<typename T = int> using P = pair<T, T>;
using Vi = V<int>; using Vl = V<ll>; using Vd = V<ld>; using VVi = V<Vi>; using VVl = V<Vl>; using Pi = P<int>; using Pl = P<ll>; using Pd = P<ld>;
constexpr ll MOD = 1000000007; constexpr int INF = (1 << 30) - 1; constexpr ll INFL = 1LL << 60; constexpr ld EPS = 1e-12; constexpr ld PI = 3.141592653589793238462643383279;
int main(void) {
int a, b; cin >> a >> b;
int c = 1;
int ans = 0;
while(1) {
if (c >= b) break;
c += a - 1;
++ans;
}
pl(ans)
return 0;
}
| 1 |
Subsets and Splits