code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin>>n&&n){
vector<int> k(n);
for(int i=0;i<n;++i)
cin>>k[i];
string s;cin>>s;
vector<char> c;
for(int i=0;i<s.size();++i){
c.emplace_back(s.at(i));
int key = k[i%k.size()];
while(key!=0){
int tmp;
if(key>26){
key -= 26;
tmp = 26;
}else{
tmp = key;
key -= key;
}
if(c[i]>='A'&&c[i]<='Z'){
c[i] -= tmp;
if(c[i]<'A'){
char sub = 'A' - c[i] - 1;
c[i] = 'z' - sub;
}
}
else if(c[i]>='a'&&c[i]<='z'){
c[i] -= tmp;
if(c[i]<'a'){
char sub = 'a' - c[i] - 1;
c[i] = 'Z' - sub;
}
}
}
cout<<c[i];
}
cout<<endl;
}
return EXIT_SUCCESS;
} | #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 100010
bool solve(){
int n;
int k[SIZE];
char c[SIZE];
scanf("%d",&n);
if(n == 0) return false;
for(int i=0;i<n;i++){
scanf("%d",k+i);
}
scanf("%s",c);
for(int i=0;c[i]!='\0';i++){
for(int j=0;j<k[i%n];j++){
if(c[i] == 'a')
c[i] = 'Z';
else if(c[i] == 'A')
c[i] = 'z';
else
c[i]--;
}
}
printf("%s\n",c);
return true;
}
int main(){
while(solve());
return 0;
} | 1 |
#include<bits/stdc++.h>
#define FL "a"
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int N=2e5+10;
const ll INF=1ll<<60;
inline ll read(){
ll d=0,w=1;char ch=getchar();
while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
if(ch=='-')w=-1,ch=getchar();
while(ch<='9'&&ch>='0')d=d*10+ch-48,ch=getchar();
return d*w;
}
inline void file(){
freopen(FL".in","r",stdin);
freopen(FL".out","w",stdout);
}
int n,q,x[N];
ll mnv[2][N<<2],lz[N<<2],ans=INF;//0:+ 1:-
#define ls (i<<1)
#define rs (i<<1|1)
#define mid ((l+r)>>1)
inline void update(int i){
mnv[0][i]=min(mnv[0][ls],mnv[0][rs]);mnv[1][i]=min(mnv[1][ls],mnv[1][rs]);
}
inline void cover(int i,ll v){lz[i]+=v;mnv[0][i]+=v;mnv[1][i]+=v;}
inline void pushdown(int i){
if(lz[i])cover(ls,lz[i]),cover(rs,lz[i]),lz[i]=0;
}
void build(int i,int l,int r){
mnv[0][i]=mnv[1][i]=INF;if(l==r)return;build(ls,l,mid);build(rs,mid+1,r);
}
inline void insert(int i,int l,int r,int p,ll v){
if(l==r){mnv[0][i]=min(mnv[0][i],v+p);mnv[1][i]=min(mnv[1][i],v-p);return;}
pushdown(i);p<=mid?insert(ls,l,mid,p,v):insert(rs,mid+1,r,p,v);update(i);
}
inline ll query(int i,int l,int r,int x,int y,int p){
if(x<=l&&r<=y)return mnv[p][i];pushdown(i);ll s=INF;
if(x<=mid)s=query(ls,l,mid,x,y,p);
if(mid<y)s=min(s,query(rs,mid+1,r,x,y,p));return s;
}
int main()
{
n=read();q=read();x[0]=read();
build(1,1,n);insert(1,1,n,read(),0);
for(int i=1;i<=q;i++)x[i]=read();
for(int i=1;i<=q;i++){
ll ql=query(1,1,n,1,x[i],1)+x[i],qr=query(1,1,n,x[i],n,0)-x[i];
cover(1,abs(x[i]-x[i-1]));insert(1,1,n,x[i-1],min(ql,qr));
}
for(int i=1;i<=n;i++)ans=min(ans,query(1,1,n,i,i,0)-i);
printf("%lld\n",ans);return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 4e18;
struct STNode {
typedef STNode* NP;
NP l, r;
int sz;
ll mi;
STNode(int _sz) : sz(_sz) {
mi = INF;
if (sz == 1) return;
l = new STNode(sz/2);
r = new STNode(sz-sz/2);
}
void set(int k, ll x) {
if (sz == 1) {
mi = min(mi, x);
return;
}
if (k < sz/2) {
l->set(k, x);
} else {
r->set(k-sz/2, x);
}
mi = min(l->mi, r->mi);
}
ll get(int a, int b) {
if (b <= 0 || sz <= a) return INF;
if (a <= 0 && sz <= b) return mi;
return min(l->get(a, b), r->get(a-sz/2, b-sz/2));
}
};
const int MN = 222222;
int n, q, a, b;
int x[MN];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> q >> a >> b;
x[0] = a;
for (int i = 1; i <= q; i++) {
cin >> x[i];
}
STNode* tr = new STNode(n+1);
STNode* tr1 = new STNode(n+1);
STNode* tr2 = new STNode(n+1);
tr->set(b, 0);
tr1->set(b, -b);
tr2->set(b, b);
ll sm = 0;
for (int i = 0; i < q; i++) {
ll c = min(tr1->get(1, x[i+1]+1) + sm + x[i+1], tr2->get(x[i+1]+1, n+1) + sm - x[i+1]);
sm += abs(x[i+1] - x[i]);
tr->set(x[i], c - sm);
tr1->set(x[i], c - x[i] - sm);
tr2->set(x[i], c + x[i] - sm);
}
cerr << tr->get(x[0], x[0]+1) + sm << endl;
cout << tr->get(1, n+1) + sm << endl;
return 0;
} | 1 |
# include <bits/stdc++.h>
typedef long long lint;
using namespace std;
lint gcd(lint x, lint y) {
if(x == 0) { return y; }
else { return gcd(y%x,x); }
}
lint lcm(lint x, lint y) { return x/gcd(x,y)*y; }
lint C(lint n, lint k) {
if(n == k) { return 1; }
else if(n < k) { return 0; }
else if(k == 0) { return 1; }
else if(k == 1) { return n; }
else return C(n-1,k-1) + C(n-1,k);
}
lint P(lint n, lint k) {
if(k == 1) { return n; }
return (n*(P(n-1,k-1)%1000000007)%1000000007);
}
int main() {
int n; cin >> n;
string s,t; cin >> s >> t;
int l;
for(l=n;l>0;l--) {
string pre = s.substr(n-l,l), suf = t.substr(0,l);
if(pre == suf) {
cout << 2*n-l << endl;
return 0;
}
}
cout << n*2 << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
lli n;
string s, t;
int main(void){
cin >> n >> s >> t;
lli ans = 2*n;
rep(i, n){
if(s.substr(i, n-i) == t.substr(0, n-i)){
ans = min(ans, n+i);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#include<string>
#define fo(i, n) for(ll i = 0; i < n; i++)
#define endl "\n"
#define of(i, n) for(ll i = n - 1; i >= 0; i--)
#define ll long long
#define vec vector<ll>
#define fio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define tr(container, it) \
for(typeof(container.begin()) it = container.begin(); it != container.end(); it++)
#define rep(i,j,n) for (ll i = j; i <= n; ++i)
#define EB emplace_back
#define mem(i,j) memset( i, j,sizeof(i))
#define ff first
#define ss second
#define ii pair<ll,ll>
#define iii pair<ll,pair<ll,ll> >
#define pb push_back
#define mp make_pair
#define all(i) i.begin(),i.end()
#define pr(a) cout<<a<<endl
#define pr
#define prv(a) for(int jkl=0; jkl<a.size();jkl++) cout<<a[jkl]<<" "; cout<<endl;
ll mod = 1e9+7;
string l,r;
ll d;
int dp[10100][2][2][101];
ll getAns(int level, int tlow, int thi, int rem)
{
if(level>=l.length())
{
if(rem==0) return 1;
else return 0;
}
if(dp[level][tlow][thi][rem]==-1)
{
int blow = 0;
int bhigh = 9;
if(tlow) blow =l[level] - '0';
if(thi) bhigh = r[level]-'0';
ll ans =0;
for(int i=blow;i<=bhigh;i++)
{
int ntlow = tlow;
int nthi = thi;
if( i > l[level]-'0') ntlow =0 ;
if(i<r[level]-'0') nthi =0;
ans += getAns(level+1, ntlow,nthi,(rem + i)%d);
ans%=mod;
}
dp[level][tlow][thi][rem] = ans;
}
return dp[level][tlow][thi][rem];
}
int main()
{
string n;
cin>>n;
r = n;
l = "1";
while(l.length()<r.length()) l += '0';
reverse(all(l));
cin>>d;
mem(dp,-1);
//cout<<r<<" "<<l<<endl;
cout<<getAns(0,1,1,0)<<endl;;
}
| #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 int long long
#define endl '\n'
#define pb push_back
#define fi first
#define se second
#define all(c) (c).begin(),(c).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define TRACE
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
const ll inf = 2e18;
const int mod = 1e9 + 7;
const int N = 1e4 + 10;
int dp[N][2][100];
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string k;
int d;
cin >> k >> d;
int n = k.length();
dp[0][1][0] = 1;
for(int i = 1; i <= n; i++) {
int cur = k[i - 1] - '0';
for(int j = 0; j <= 9; j++) {
for(int rem = 0; rem < d; rem++) {
dp[i][0][(rem + j) % d] = (dp[i][0][(rem + j) % d] + dp[i - 1][0][rem]) % mod;
if(j < cur) {
dp[i][0][(rem + j) % d] = (dp[i][0][(rem + j) % d] + dp[i - 1][1][rem]) % mod;
}
if(j == cur) {
dp[i][1][(rem + j) % d] = (dp[i][1][(rem + j) % d] + dp[i - 1][1][rem]) % mod;
}
}
}
}
cout << (dp[n][0][0] + dp[n][1][0] - 1 + mod) % mod;
return 0;
} | 1 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
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;}
const ll INF=1e9+1;
int main(){
ll a,b,c,d;
cin >> a >> b >> c >> d;
if(a+b>c+d){
cout << "Left" << endl;
}
else if(a+b==c+d){
cout << "Balanced" << endl;
}
else{
cout << "Right" << endl;
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main() {
double x1, y1, x2, y2, x, y, ans;
cin >> x1 >> y1 >> x2 >> y2;
x = x1 - x2;
y = y1 - y2;
ans = sqrt(x*x + y*y);
printf("%f", ans);
return 0;
} | 0 |
/**Lucky Boy**/
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define FORD(i, a, b) for (int i = (a); i >= (b); --i)
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define maxn 200005
#define maxm 1000006
#define maxc 1000000007
#define pii pair <int,int>
#define Task ""
#define double long double
template <typename T> inline void read(T &x){char c;bool nega=0;while((!isdigit(c=getchar()))&&(c!='-'));if(c=='-'){nega=1;c=getchar();}x=c-48;while(isdigit(c=getchar())) x=x*10+c-48;if(nega) x=-x;}
template <typename T> inline void writep(T x){if(x>9) writep(x/10);putchar(x%10+48);}
template <typename T> inline void write(T x){if(x<0){putchar('-');x=-x;}writep(x);putchar(' ');}
template <typename T> inline void writeln(T x){write(x);putchar('\n');}
const double Pi = acos(-1);
using namespace std;
int n,t[55][55];
pii a[maxn];
long long ans;
int Get(int u,int v)
{
if (!u || !v) return 0;
int res = 0;
while (u)
{
int temp = v;
while (temp)
{
res += t[u][temp];
temp -= temp & -temp;
}
u -= u & -u;
}
return res;
}
void Update(int u,int v,int val)
{
while (u <= 50)
{
int temp = v;
while (temp <= 50)
{
t[u][temp] += val;
temp += temp & -temp;
}
u += u & -u;
}
}
int main()
{
srand(time(NULL));
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie();
if(fopen(".inp", "r")) freopen(".inp", "r", stdin);
//freopen(Task".inp", "r",stdin);
//freopen(Task".out", "w",stdout);
cin >> n;
FOR(i,1,n)
{
double x;cin >> x;
long long u = round(x * 1e9);
while (u % 2 == 0)
{
++a[i].F;
u >>= 1;
}
while (u % 5 == 0)
{
++a[i].S;
u /= 5;
}
}
FOR(i,1,n)
{
int need2 = max(1,18 - a[i].F + 1),
need5 = max(1,18 - a[i].S + 1);
ans += Get(50,50);
ans -= Get(need2 - 1,50);
ans -= Get(50,need5 - 1);
ans += Get(need2 - 1,need5 - 1);
Update(a[i].F + 1,a[i].S + 1, 1);
}
cout << ans;
return 0;
}
| #include<bits/stdc++.h>
#define Imposter ios_base::sync_with_stdio(false);cin.tie(NULL);
#define pb push_back
#define ll long long int
#define ld long double
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("O3")
using namespace __gnu_pbds;
#define ordered_set tree<ll, null_type,less_equal<ll>, rb_tree_tag,tree_order_statistics_node_update>//s.order_of_key(val) *s.find_by_order(ind)
using namespace std;
#define f(n) for(ll i=0;i<n;i++)
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define input(arr,n) for(ll i1=0;i1<n;i1++ )cin>>arr[i1]
#define endl "\n"
#define vll vector<ll>
#define vlll vector<vll>
#define all(x) x.begin(),x.end()
int n;
inline void solve()
{
cin>>n;
int a[n+2];
for(int i=1;i<=n;i++)
cin>>a[i];
a[0]=0;
a[n+1]=0;
ll sum=0;
for(int i=1;i<n+2;i++)
{
sum+=abs(a[i]-a[i-1]);
}
//cout<<sum<<endl;
for(int i=1;i<=n;i++)
{
cout<<sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+ abs(a[i+1]-a[i-1])<<endl;
}
}
int main()
{
Imposter
int t=1;
//cin>>t;
while(t--)
{
cout<<fixed<<setprecision(10);
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int v[128];
int n;
std::cin >> n;
for(int i = 0; i < n; ++i) {
std::cin >> v[i];
}
for(int i = n-1; i > 0; --i) {
std::cout << v[i] << " ";
}
std::cout << v[0] << std::endl;
return 0;
} | #include <iostream>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <cstring>
#include <functional>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
#define rep(i, n) for(long long i=0; i<n; i++)
#define reps(i, s, e) for(long long i=s; i<e; i++)
#define repr(i, n) for(long long i=n-1; i>=0; i--)
#define reprs(i, s, e) for(long long i=e-1; i>=s; i--)
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n; cin >> n;
ll a[n];
rep(i, n){
cin >> a[i];
}
double a_sum = accumulate(a, a+n, 0LL);
double ave = a_sum / n;
double vmin = 1e18;
ll i_ans = 0;
rep(i, n){
double dif = abs(ave - a[i]);
if(dif < vmin){
i_ans = i;
vmin = dif;
}
}
cout << i_ans << endl;
return 0;
} | 0 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
long long n,m,sum=0;
cin>>n;
vector<long long> vec;
for(int i=0;i<n;++i){
cin>>m;
vec.push_back(m);
sum+=m;
}
sort(vec.begin(),vec.end());
long long max,min;
max=vec[n-1];
min=vec[0];
cout<<min<<" "<<max<<" "<<sum<<endl;
return 0;
} | #include<iostream>
int main(void){
int n, min = 1000000, max = -1000000;
long long sum = 0;
std::cin >> n;
if (n == 0) return 0;
for (int i = 0; i < n; i++){
int x;
std::cin >> x;
sum = sum + x;
if (min > x) min = x;
if (max < x) max = x;
}
std::cout << min << " " << max << " " << sum << std::endl;
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <map>
const int lens = 1e5 + 1;
long long n,m,a[lens],sum[lens];
std::map<long long,long long> map;
int main()
{
std::ios::sync_with_stdio(false);
std::cin >> n >> m;
for(int i = 1;i <= n;i++)
{
std::cin >> a[i];
}
long long ans = 0;
map[0]++;
for(int i = 1;i <= n;i++)
{
sum[i] = (sum[i - 1] + a[i]) % m;
ans += map[sum[i]];
map[sum[i]]++;
}
std::cout << ans;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) std::cout << x << '\n'
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define sz(x) ((int)(x).size())
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { ll g = gcd(a, b); return a / g * b; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
const int INF = INT_MAX / 2;
const ll inf = LLONG_MAX / 2;
const int mod = 1000000007;
const int MAX_N = 101010;
const long double PI = acos(-1);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
/*------------------------------*/
ll n, m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
map<ll, ll> mp;
ll sum = 0;
mp[sum]++;
for (int i = 0; i < n; i++) {
sum += a[i];
mp[sum % m]++;
}
ll ans = 0;
for (auto m : mp) {
ans += m.second * (m.second - 1) / 2;
}
out(ans);
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <set>
#include <stack>
#include <algorithm>
using namespace std;
struct SccKosaraju {
int n;
vector<vector<int>> g;
vector<vector<int>> rg;
vector<bool> visited;
vector<int> sccno;
int sccCount = 0;
vector<int> s;
SccKosaraju(int n): n(n) {
g.assign(n, vector<int>());
rg.assign(n, vector<int>());
visited.assign(n, false);
sccno.assign(n, -1);
}
void addEdge(int from, int to) {
g[from].push_back(to);
rg[to].push_back(from);
}
void solve() {
for (int i = 0; i < n; i++) {
if (!visited[i]) {
dfs1(i);
}
}
for (int i = n - 1; i >= 0; i--) {
if (sccno[s[i]] == -1) {
sccCount++;
dfs2(s[i]);
}
}
}
bool sameScc(int u, int v) {
return sccno[u] == sccno[v];
}
void dfs1(int u) {
visited[u] = true;
for (int v : g[u]) {
if (!visited[v]) {
dfs1(v);
}
}
s.push_back(u);
}
void dfs2(int u) {
sccno[u] = sccCount;
for (int v : rg[u]) {
if (sccno[v] == -1) {
dfs2(v);
}
}
}
};
int main() {
int n, m;
cin >> n >> m;
SccKosaraju scc(n);
for (int i = 0; i < m; i++) {
int from, to;
cin >> from >> to;
scc.addEdge(from, to);
}
scc.solve();
// for (int i = 0; i < n; i++) {
// cout << i << " " << scc.sccno[i] << endl;
// }
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int u, v;
cin >> u >> v;
cout << (scc.sameScc(u, v)? 1 : 0) << endl;
}
return 0;
} | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define forever for (;;)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
template<typename A> using V = std::vector<A>;
template<typename A> using F = std::function<A>;
template<typename A, typename B> using P = std::pair<A, B>;
using pii = P<int, int>;
using vi = V<int>;
using vd = V<double>;
using vs = V<std::string>;
using vpii = V<pii>;
using vvi = V<vi>;
using vvpii = V<vpii>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979;
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int n) { return n & 1; }
constexpr bool even(const int n) { return ~n & 1; }
template<typename T> std::istream &operator>>(std::istream &is, std::vector<T> &v) { for (T &x : v) is >> x; return is; }
template<typename A, typename B> std::istream &operator>>(std::istream &is, std::pair<A, B> &p) { is >> p.first; is >> p.second; return is; }
using namespace std;
// clang-format on
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(const int s = 0, const int d = 0, const Weight w = 0) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
class Graph {
std::vector<Edges> g;
using iterator = std::vector<Edges>::iterator;
using const_iterator = std::vector<Edges>::const_iterator;
public:
Graph(const int size = 0) : g(size) {}
size_t size() const { return g.size(); }
const Edges &operator[](const int i) const { return g[i]; }
void addArc(const int src, const int dst, const Weight w = 1) { g[src].emplace_back(src, dst, w); }
void addEdge(const int node1, const int node2, const Weight w = 1) {
addArc(node1, node2, w);
addArc(node2, node1, w);
}
iterator begin() { return g.begin(); }
const_iterator begin() const { return g.begin(); }
iterator end() { return g.end(); }
const_iterator end() const { return g.end(); }
};
std::vector<int> kosaraju(const Graph &g) {
int n = g.size(), m = 0;
Graph rg(n);
std::vector<int> stk, cmp(n, -1), added(n), visited(n), ord(n);
for (auto &es : g) {
for (auto &e : es) rg.addArc(e.dst, e.src, e.weight);
m += es.size();
}
stk.resize(n + m);
m = 0;
for (int i = 0; i < n; i++) {
if (visited[i]) continue;
int s = 0;
stk[s++] = i;
while (s != 0) {
int v = stk[s - 1];
visited[v] = true;
bool pushed = false;
for (auto &e : g[v]) {
if (!visited[e.dst]) {
stk[s++] = e.dst;
pushed = true;
}
}
if (pushed) continue;
int t = stk[s - 1];
if (!added[t]) {
added[t] = true;
ord[n - ++m] = t;
}
--s;
}
}
int k = 0;
for (int u : ord) {
if (cmp[u] != -1) continue;
int s = 0;
stk[s++] = u;
while (s != 0) {
int v = stk[--s];
cmp[v] = k;
for (auto &e : rg[v]) {
if (cmp[e.dst] == -1) stk[s++] = e.dst;
}
}
++k;
}
return cmp;
}
main {
int n, m;
cin >> n >> m;
Graph g(n);
while (m--) {
int s, t;
cin >> s >> t;
g.addArc(s, t);
}
int q;
cin >> q;
vi scc = kosaraju(g);
while (q--) {
int u, v;
cin >> u >> v;
cout << (scc[u] == scc[v]) << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define INF 999999999999999999
#define rep(i,m,n) for(lli i = m;i < n;i++)
#define rrep(i,m,n) for(lli i=m-1;i>=n;i--)
#define pb(n) push_back(n)
#define UE(N) N.erase(unique(N.begin(),N.end()),N.end());
#define Sort(n) sort(n.begin(), n.end())
#define Rev(n) reverse(n.begin(),n.end())
#define Out(S) cout << S << endl
#define NeOut(S) cout << S
#define HpOut(S) cout << setprecision(25) << S << endl
#define Vec(K,L,N,S) vector<L> K(N,S)
#define DV(K,L,N,M,S) vector<vector<L>> K(N,vector<L>(M,S))
#define TV(K,L,N,M,R,S) vector<vector<vector<L>>> K(N,vector<vector<L>>(M,vector<L>(R,S)))
#define pint pair<lli,lli>
#define paf(L,R) pair<L,R>
#define mod 1000000007
#define MAX 510000
#define ALL(a) a.begin(),a.end()
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
int main(){
lli A,B,C,D,E,F,N,M,K,L,X,Y,Z,H,W,sum=0,num=0,flag=0;string S,T;
cin >> X >> Y;
if(X==3)sum+=100000;
if(X==2)sum+=200000;
if(X==1)sum+=300000;
if(Y==3)sum+=100000;
if(Y==2)sum+=200000;
if(Y==1)sum+=300000;
if(X==Y&&Y==1)sum+=400000;
Out(sum);
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
cout << (100000 * (max(0, 4 - x) + max(0, 4 - y)) + (x == 1 && y == 1 ? 400000 : 0)) << endl;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
using namespace std;
typedef pair<int, int> P;
int k, a[100000], dist[100000];
vector<int> v[100000];
vector<P> w;
bool b[100000];
void cal(int x, int y){
dist[x] = y;
b[x] = false;
w.push_back(P(y, x));
for(int i=0;i<v[x].size();i++){
cal(v[x][i], y+1);
}
}
int hin(int x, int y){
if(b[x])return 0;
b[x] = true;
if(x == 0 || (a[x] == 0 && y == k-1))return 0;
if(y == k-1)return 1;
return hin(a[x], y+1);
}
int main() {
int n, ans = 0;
cin >> n >> k >> a[0];
if(--a[0] != 0)ans++;
for(int i=1;i<n;i++){
cin >> a[i];
v[--a[i]].push_back(i);
}
cal(0, 0);
sort(w.begin(), w.end(), greater<P>());
for(int i=0;i<w.size();i++){
int p = w[i].second;
if(!b[p]){
ans += hin(p, 0);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
vector<int> adjlist[100005];
int mx[100005];
int ans = 0;
int n,k;
void dfs(int u){
mx[u] = 0;
for (auto v : adjlist[u]){
dfs(v);
if (mx[v] == k && u != 1){
ans++;
}
else{
mx[u] = max(mx[u],mx[v]);
}
}
mx[u]++;
}
int main(){
scanf("%d%d",&n,&k);
for (int i = 1,x; i <= n; i++){
scanf("%d",&x);
if (i == 1){
if (x != 1){
ans++;
}
}
else adjlist[x].push_back(i);
}
dfs(1);
printf("%d",ans);
}
| 1 |
#include <bits/stdc++.h>
#define int long long
#define ci(m) for(int i=0;i<m;i++)
#define cj(m) for(int j=0;j<m;j++)
#define ck(m) for(int k=0;k<m;k++)
#define gcd __gcd
#define endl "\n"
#define pb emplace_back
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define mod2 998244353
#define maxe *max_element
#define mine *min_element
#define inf 1e18
#define deci(x, y) fixed<<setprecision(y)<<x
#define w(t) int t; cin>>t; while(t--)
#define nitin ios_base::sync_with_stdio(false); cin.tie(NULL)
#define PI 3.141592653589793238
using namespace std;
int n,m;
int ans=INT_MAX;
int a[500][500];
void solve(int num,set<int>&s)
{
if(num==m)
{
return ;
}
vector<int>v(m+1,0);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
if(s.count(a[i][j]))
continue;
else
{
v[a[i][j]]++;
break;
}
}
}
int val=maxe(v.begin(),v.end());
ans=min(ans,val);
for(int i=1;i<=m;i++)
{
if(v[i]==val)
{
s.insert(i);
solve(num+1,s);
return;
}
}
}
int32_t main() {
nitin;
cin>>n>>m;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
cin>>a[i][j];
}
}
set<int>s;
solve(0,s);
cout<<ans<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int read() {
char cc = getchar(); int cn = 0, flus = 1;
while(cc < '0' || cc > '9') { if( cc == '-' ) flus = -flus; cc = getchar(); }
while(cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const int N = 1000 + 5 ;
#define rep( i, s, t ) for( register int i = s; i <= t; ++ i )
int n, m, book[N], w[N][N], vis[N], can[N];
bool check( int x ) {
memset( book, 0, sizeof(book) ), memset( can, 0, sizeof(can) ) ;
int flag ; rep( i, 1, n ) vis[i] = 1, ++ book[w[i][vis[i]]] ;
rep( i, 1, m ) {
flag = 1 ;
rep( j, 1, n ) {
int u = w[j][vis[j]] ;
if( book[u] > x ) {
can[u] = 1; flag = 0 ;
while( vis[j] <= n && can[w[j][vis[j]]] ) ++ vis[j] ;
if( vis[j] > n ) return 0;
++ book[w[j][vis[j]]] ;
}
}
if( flag ) return 1;
}
return 0 ;
}
signed main()
{
n = read(), m = read() ;
rep( i, 1, n ) rep( j, 1, m ) w[i][j] = read() ;
int l = 1, r = n, ans = 0, mid ;
while( l <= r ) {
mid = ( l + r ) >> 1 ;
if( check(mid) ) ans = mid, r = mid - 1 ;
else l = mid + 1 ;
}
printf("%d\n", ans ) ;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
constexpr int NUM_BITS = 18;
template<typename T>
vector<vector<T>> Make2DVector(int d1, int d2, T default_value) {
return vector<vector<T>>(d1, vector<T>(d2, default_value));
}
// Returns a tuple of (l, u) s.t.
// - l is the minimum value s.t. is_upper_fn(l) is false.
// - r is the minimum value s.t. is_upper_fn(r) is true.
//
// Required:
// - is_upper_fn is a function s.t.
// - There exists a constant c s.t. is_upper_fn(x) is true for x >= c and
// is_upper_fn(x) is false for x < c.
// - is_upper_fn(min_value) is false.
// - is_upper_fn(max_value) is true.
//
// Verified: ABC144E
tuple<int64, int64> BinarySearch(function<bool(int64)> is_upper_fn, int64 l, int64 u) {
while (u - l >= 2) {
int64 m = (l + u) / 2;
if (is_upper_fn(m)) u = m; else l = m;
}
return make_tuple(l, u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int64> xs(n);
for (int i = 0; i < n; i++) {
cin >> xs[i];
}
int64 c;
cin >> c;
auto next_table = Make2DVector(NUM_BITS, n, -1);
for (int i = 0; i < n; i++) {
next_table[0][i] = i;
if (i > 0) next_table[0][i] = next_table[0][i - 1];
while (next_table[0][i] + 1 < n && xs[next_table[0][i] + 1] - xs[i] <= c) {
next_table[0][i]++;
}
}
for (int b = 1; b < NUM_BITS; b++) {
for (int i = 0; i < n; i++) {
next_table[b][i] = next_table[b - 1][next_table[b - 1][i]];
}
}
int q_count;
cin >> q_count;
for (int q = 0; q < q_count; q++) {
int a, b;
cin >> a >> b;
a--;
b--;
if (a > b) swap(a, b);
auto is_upper_fn = [&](int k) -> bool {
int v = a;
for (int b = 0; b < NUM_BITS; b++) {
if (k & (1 << b)) {
v = next_table[b][v];
}
}
return v >= b;
};
int l = 0;
int u = n - 1;
tie(l, u) = BinarySearch(is_upper_fn, l, u);
cout << u << "\n";
}
} | #include <bits/stdc++.h>
using namespace std;
int x[100005];
int par1[17][100005], par2[17][100005];
int main(){
int n, l, q;
scanf("%d", &n);
for(int i=1;i<=n;i++) scanf("%d", &x[i]);
scanf("%d%d", &l, &q);
for(int i=1;i<=n-1;i++){
int lo = i+1, hi = n, ans;
while(lo <= hi){
int mid = (lo+hi)/2;
if(x[mid]-x[i] <= l) ans = mid, lo = mid+1;
else hi = mid-1;
}
par1[0][i] = ans;
}
for(int i=n;i>=2;i--){
int lo = 1, hi = i-1, ans;
while(lo <= hi){
int mid = (lo+hi)/2;
if(x[i]-x[mid] <= l) ans = mid, hi = mid-1;
else lo = mid+1;
}
par2[0][i] = ans;
}
for(int j=1;j<17;j++){
for(int i=1;i<=n;i++){
if(par1[j-1][i] != 0) par1[j][i] = par1[j-1][par1[j-1][i]];
if(par2[j-1][i] != 0) par2[j][i] = par2[j-1][par2[j-1][i]];
}
}
for(int i=1;i<=q;i++){
int a, b, ans = 0;
scanf("%d%d", &a, &b);
if(a < b){
for(int j=16;j>=0;j--){
if(par1[j][a] == 0) continue;
if(par1[j][a] <= b){
a = par1[j][a];
ans += (1<<j);
}
}
if(a != b) ans++;
}
else{
for(int j=16;j>=0;j--){
if(par2[j][a] == 0) continue;
if(par2[j][a] >= b){
a = par2[j][a];
ans += (1<<j);
}
}
if(a != b) ans++;
}
printf("%d\n", ans);
}
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
using int_vec = vector<int>;
using Iterator = int_vec::iterator;
Iterator partition(Iterator begin, Iterator end, int x) {
for (auto it = begin; it != end; ++it) {
if (*it <= x) {
swap(*begin++, *it);
}
}
return begin-1;
}
int main() {
int n;
cin >> n;
int_vec v;
for (auto i = 0; i < n; ++i) {
int x;
cin >> x;
v.push_back(x);
}
auto mid = partition(v.begin(), v.end(), v.back());
auto it = v.begin();
for (; it != v.end()-1; ++it) {
if (it == mid) {
cout << "[" << *it << "]" << " ";
} else {
cout << *it << " ";
}
}
cout << *it << endl;
return 0;
} | #include<iostream>
#include<string>
#include<queue>
#include<algorithm>
#include<cstdio>
#include<vector>
#include<stack>
#include<map>
#include<iterator>
#include<cstdlib>
#include<cmath>
using namespace std;
#define MAX 100000
#define SENTINEL 2000000000
int A[MAX],n;
int partition(int p,int r)
{
int x,i,j,t;
x = A[r];
i = p-1;
for(j=p;j<r;j++)
{
if(A[j]<=x)
{
i++;
t = A[i];A[i] = A[j];A[j] = t;
}
}
t = A[i+1];A[i+1] = A[r];A[r] = t;
return i+1;
}
int main()
{
int i,q;
scanf("%d",&n);
for(i=0;i<n;i++) scanf("%d",&A[i]);
q = partition(0,n-1);
for(i=0;i<n;i++)
{
if(i) printf(" ");
if(i==q)printf("[");
printf("%d",A[i]);
if(i==q)printf("]");
}
printf("\n");
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<V>;
using VVV = vector<VV>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VVVL = vector<VVL>;
template<class T> using P = pair<T, T>;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define REP(i,k,n) for(int i=(k);i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define output(x,y) cout << fixed << setprecision(y) << x << endl;
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; }
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; }
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
ll upper = MOD + MOD;
ll under = -upper;
ll UPPER = MOD * MOD;
ll UNDER = -UPPER;
const long double pi = 3.141592653589793;
int dx[4] = { 0,-1,0,1 };
int dy[4] = { -1,0,1,0 };
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) {
cin >> s[i];
}
queue<P<int>> que;
VV dist(h, V(w, upper));
rep(i, h) rep(j, w) {
if (s[i][j] == '#') {
que.push(make_pair(i, j));
dist[i][j] = 0;
}
}
while (!que.empty()) {
P<int> p = que.front();
que.pop();
int y = p.first;
int x = p.second;
rep(dir, 4) {
int ny = y + dy[dir];
int nx = x + dx[dir];
if (ny < 0 || ny >= h || nx < 0 || nx >= w) continue;
if (dist[ny][nx] != upper) continue;
dist[ny][nx] = dist[y][x] + 1;
que.push(make_pair(ny, nx));
}
}
int ans = 0;
rep(i, h) rep(j, w) {
chmax(ans, dist[i][j]);
}
cout << ans << endl;
return 0;
} | #include <cstdio>
#include <algorithm>
using namespace std;
int N, M, p[1001], s[1001 * 1001];
int main(){
while(scanf("%d%d", &N, &M) != EOF && (N|M)){
for(int x = 0; x < N; x++){
scanf("%d", p+x);
}
p[N++] = 0;
for(int x = 0; x < N; x++){
for(int y = 0; y < N; y++){
s[N*x + y] = p[x] + p[y];
}
}
sort(s, s+N*N);
int ans = 0;
for(int x = 0; x < N*N; x++){
int* lb = lower_bound(s, s + N * N, M - s[x]);
if(lb != s) --lb;
if(s[x] + *lb > M) continue;
ans = max(ans, s[x] + *lb);
}
printf("%d\n", ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL (-1)
#define LL long long
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
int64_t n, m, d;
cin >> n >> m >> d;
double ans;
if (!d) {
double p = (double)n / (n * n);
ans = (double)p * (m - 1);
}
else {
double p = (double)2 * (n - d) / (n * n);
ans = (double)p * (m - 1);
}
cout << fixed << setprecision(10) << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
string sa;
while(getline(cin,sa)){
for(int j=0;j<26;j++){
int a=sa.size();
for(int i=0;i<a;i++){
if(sa[i]>='a'&&sa[i]<='z'){
sa[i]+=1;
if(sa[i]>'z'){
sa[i]-=26;
}
}
}
size_t z=sa.find("this");
size_t za=sa.find("that");
size_t zb=sa.find("the");
if(z!=string::npos){break;}
else if(za!=string::npos){break;}
else if(zb!=string::npos){break;}
}
cout<<sa<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll income[1010011];
vector<ll>adj[1010011];
map<ll,ll>m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin>>n;
ll num;
ll cur=1;
for(ll i=1;i<=n;i++)
{
for(ll j=i+1;j<=n;j++)
{
if(i!=j)
{
ll mini=min(i,j);
ll maxi=max(i,j);
m[mini*10000+maxi]=cur;
cur++;
}
}
}
for(ll i=1;i<=n;i++)
{
ll num1;
cin>>num1;
ll i1=m[min(i,num1)*10000+max(i,num1)];
for(ll j=2;j<n;j++)
{
cin>>num;
ll mini=min(i,num);
ll maxi=max(i,num);
ll i2=m[min(i,num)*10000+max(i,num)];
//cout<<i1<<" "<<i2<<endl;
adj[i1].push_back(i2);
income[i2]+=1;
//cout<<i2<<" "<<income[i2]<<endl;
i1=i2;
}
}
//cout<<income[1]<<" "<<income[2]<<" "<<income[3]<<endl;
//for(ll i=1;i<cur;i++)
// cout<<income[i]<<" "<<i<<endl;;
vector<ll>v;
ll ans=1;
for(ll i=1;i<cur;i++)
{
if(income[i]==0)
{
v.push_back(i);
}
}
//cout<<v.size()<<endl;
if(v.size()==0)
{
cout<<"-1";
return 0;
}
while(1)
{
vector<ll>v1;
ll flag=0;
for(ll i=0;i<v.size();i++)
{
for(ll j:adj[v[i]])
{
income[j]-=1;
if(income[j]==0)
{
v1.push_back(j);
flag=1;
}
}
}
if(flag==1)
{
ans++;
v.clear();
for(ll i=0;i<v1.size();i++)
{
v.push_back(v1[i]);
}
}
else{
break;
}
}
for(ll i=1;i<cur;i++)
{
if(income[i]>0)
{
cout<<"-1";
return 0;
}
}
cout<<ans;
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
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 maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
vector<ll> pw2(62,1);vector<ll> pw10(19,1);
//x vs y
//の試合の数字を返す
vector<vector<ll> > memo(1001,vector<ll>(1001,INF));
ll cnt=0;
ll game(ll x,ll y){
if(x>y) swap(x,y);
if(memo[x][y]!=INF) return memo[x][y];
else return memo[x][y]=++cnt;
}
vector<ll> G[500050];//辺
//v:足跡
//c:cからのdfsの終了証明
vector<ll> visited(500050);
vector<ll> calculated(500050);
//d:c済みのとき、そのdfsの深さ
vector<ll> d(500050);
//最長経路を返す,閉路あれば-1
ll dfs(ll x){
if(visited[x]){
//dfs終わってないくせにまた訪れた = 閉路
if(!calculated[x]) return -1;
else return d[x];
}
//あしあと
visited[x]=true;
//枝先のmaxをとる
ll ret=0;
rep(i,sz(G[x])){
ll tmp=dfs(G[x][i]);
//-1は即伝搬
if(tmp==-1) return -1;
//更新作業
chmax(ret,tmp);
}
//dfs終了!
calculated[x]=true;
return d[x]=ret+1;
}
int main(){
//dの初期化
rep1(i,500049) d[i]=INF;
//入力
ll N; cin>>N;
ll ans=0;
vector<vector<ll> > A(N+1,vector<ll>(N,0));
rep1(i,N){
rep1(j,N-1){
cin>>A[i][j];
}
}
//初日にやる試合をリストへ
vector<ll> dfs_list;
//iとjが初日のペアなら初日にやって良い
//inする
rep1(i,N-1){
FOR(j,i+1,N+1){
if(A[A[i][1]][1]==i) dfs_list.pb(game(i,j));
}
}
//試合の前後を表す辺を張る
rep1(i,N){
//iは、A[i][j]との試合の後にしかA[i][j+1]との試合をできない
rep1(j,N-2){
G[game(i,A[i][j])].pb(game(i,A[i][j+1]));
}
}
if(sz(dfs_list)==0) cout<<-1<<endl;
else{
rep(i,sz(dfs_list)){
ll tmp=dfs(dfs_list[i]);
//閉路発見
if(tmp==-1){
cout<<-1<<endl;
return 0;
}
chmax(ans,tmp);
}
cout<<ans<<endl;
}
}
| 1 |
#include <bits/stdc++.h>
#if defined(__GNUC__)
#pragma GCC optimize ("Ofast")
#endif
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef pair<ll, ll> pll;
#define debug(x) cerr<<#x<<'='<<(x)<<endl;
#define debugp(x) cerr<<#x<<"= {"<<(x.first)<<", "<<(x.second)<<"}"<<endl;
#define debug2(x, y) cerr<<"{"<<#x<<", "<<#y<<"} = {"<<(x)<<", "<<(y)<<"}"<<endl;
#define debugv(v) cerr<<#v<<" : ";for (auto x:v) cerr<<x<<' ';cerr<<endl;
#define all(x) x.begin(), x.end()
#define pb push_back
#define kill(x) return cout<<x<<'\n', 0;
const ld eps=1e-7;
const int inf=1000000010;
const ll INF=10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 310, LOG=20;
int n, m, k, u, v, x, y, t, a, b, ans;
int dp[MAXN][MAXN][MAXN];
string S;
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
cin>>S>>k;
n=S.size();
S="."+S;
for (int i=n; i; i--){
for (int x=0; x<=k; x++) dp[i][i][x]=1;
for (int j=i+1; j<=n; j++){
dp[i][j][0]=max(dp[i+1][j][0], dp[i][j-1][0]);
if (S[i]==S[j]) dp[i][j][0]=max(dp[i][j][0], dp[i+1][j-1][0]+2);
for (int x=1; x<=k; x++){
dp[i][j][x]=max(dp[i+1][j][x], dp[i][j-1][x]);
dp[i][j][x]=max(dp[i][j][x], 2+dp[i+1][j-1][x-(S[i]!=S[j])]);
}
}
}
cout<<dp[1][n][k]<<'\n';
return 0;
}
| #include <algorithm>
#include <cctype>
#include <cstring>
#include <cstdio>
using namespace std;
inline int read(int f = 1, int x = 0, char ch = ' ')
{
while(!isdigit(ch = getchar())) if(ch == '-') f = -1;
while(isdigit(ch)) x = x*10+ch-'0', ch = getchar();
return f*x;
}
const int N = 3e2+5;
int n, m, f[N][N][N], ans; char s[N];
int main()
{
scanf("%s", s+1), n = strlen(s+1), m = read();
for(int i = 1; i <= n; ++i) f[0][i][i] = 1;
for(int k = 0; k <= m; ++k)
for(int l = 2; l <= n; ++l)
for(int i = 1, j = l; j <= n; ++i, ++j)
{
f[k][i][j] = max(f[k][i+1][j], f[k][i][j-1]);
if(s[i] == s[j]) f[k][i][j] = max(f[k][i][j], f[k][i+1][j-1]+2);
if(k) f[k][i][j] = max(f[k][i][j], f[k-1][i+1][j-1]+2);
}
for(int i = 0; i <= m; ++i) ans = max(ans, f[i][1][n]);
printf("%d\n", ans);
return 0;
} | 1 |
#include <cstdio>
#include <cstring>
using namespace std;
int map[22][22];
int st[2],gl[2];
int n,m,ans;
int move[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
void dfs(int x,int y,int z){
if(z>=ans)return;
for(int i=0;i<4;i++){
int xx=x,yy=y;
if(map[x+move[i][0]][y+move[i][1]]!=0&&map[x+move[i][0]][y+move[i][1]]!=3)continue;
for(int j=0;map[xx][yy]==0;j++){
xx+=move[i][0];
yy+=move[i][1];
if(map[xx][yy]==3){
ans=z;
return;
}
}
if(map[xx][yy]==1){
map[xx][yy]=0;
dfs(xx-move[i][0],yy-move[i][1],z+1);
map[xx][yy]=1;
}
}
}
int main(){
scanf("%d%d",&m,&n);
while(n*m!=0){
for(int i=0;i<=n+1;i++){
map[i][0]=-1;
map[i][m+1]=-1;
}
for(int i=0;i<=m+1;i++){
map[0][i]=-1;
map[n+1][i]=-1;
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
scanf("%d",&map[i][j]);
if(map[i][j]==2){
st[0]=i;st[1]=j;
map[i][j]=0;
}
}
ans=11;
dfs(st[0],st[1],1);
if(ans>10)ans=-1;
printf("%d\n",ans);
scanf("%d%d",&m,&n);
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <istream>
#include <sstream>
#include <iomanip>
#include <iterator>
#include <climits>
using namespace std;
typedef ostringstream OSS;
typedef istringstream ISS;
typedef vector<int> VI;
typedef vector< VI > VVI;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
#define X first
#define Y second
const LL MOD = 1000000007;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int INF = INT_MAX;
PII S;
PII T;
int W, H;
int ans;
void move(VVI ts, PII p, int n) {
if (++n > 10) {
return;
}
for (int i = 0; i < 4; i++) {
int x = p.X;
int y = p.Y;
bool first = true;
while (true) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= W || ny >= H) {
break;
}
if (first && ts[ny][nx] == 1) {
break;
}
first = false;
if (ts[ny][nx] == 3) {
ans = min(ans, n);
break;
}
if (ts[ny][nx] == 1) {
VVI nts(ts);
nts[ny][nx] = 0;
move(nts, make_pair(x, y), n);
break;
}
x = nx;
y = ny;
}
}
}
int main(void) {
while (cin >> W >> H, W) {
VVI ts(H, VI(W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> ts[i][j];
if (ts[i][j] == 2) {
S = make_pair(j, i);
}
if (ts[i][j] == 3) {
T = make_pair(j, i);
}
}
}
VI pattern(10, 0);
ans = INF;
move(ts, S, 0);
cout << (ans == INF ? -1 : ans) << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define fi first
#define se second
#define rep(i,n) for(int i=0;i<(n);i++)
int main(){
ll n,t,x; cin>>n>>t;
ll px=-1,ans=0;
for(ll i=0;i<n;i++){
cin>>x;
ans+=t;
if(px!=-1) ans-=max((ll)0,px-x+t);
px=x;
}
cout<<ans;
}
| #include <iostream>
#include <string>
#include <stdio.h>
using namespace std;
int main(){
int n,m;
string S;
int dice[6];
for(int i=0;i<6;i++){
cin>>dice[i];
}
cin>>S;
for(int i=0;i<S.size();i++){
if(S[i]=='N'){
m=dice[0];
dice[0]=dice[1];
dice[1]=dice[5];
dice[5]=dice[4];
dice[4]=m;
}
else if(S[i]=='S'){
m=dice[0];
dice[0]=dice[4];
dice[4]=dice[5];
dice[5]=dice[1];
dice[1]=m;
}
else if(S[i]=='W'){
m=dice[0];
dice[0]=dice[2];
dice[2]=dice[5];
dice[5]=dice[3];
dice[3]=m;
}
else if(S[i]=='E'){
m=dice[0];
dice[0]=dice[3];
dice[3]=dice[5];
dice[5]=dice[2];
dice[2]=m;
}
m=0;
}
cout<<dice[0]<<endl;
return 0;
}
| 0 |
#include <stdio.h>
#include <limits.h>
#include <math.h>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cstring>
#include <string>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
#define VARIABLE(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x);
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
const int INF = 1000000000;
typedef double D;
const double EPS = 1e-8;
const double PI = 3.14159;
int dx[4]={-1, 0, 1, 0}, dy[4]={0, -1, 0, 1};
using namespace std;
//typedef pair<int, int> P;
/** Problem0546 : Lining up the cards **/
vector<string> card;
bool used[10];
set<string> ans;
int N, K;
void solve(int n, string s)
{
if (n==K) ans.insert(s);
else {
rep(i, N) {
if (!used[i]) {
used[i] = true;
solve(n+1, s+card[i]);
used[i] = false;
}
}
}
}
int main()
{
while (cin>>N, N) {
ans.clear();
card.clear();
fill(used, used+10, false);
cin>>K;
rep(i, N) {
string s; cin>>s;
card.push_back(s);
}
solve(0, "");
cout << ans.size() << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
const int maxn=100010,mod=998244353;
const char str[2][10]={"First","Second"};
#define lson o<<1,l,mid
#define rson o<<1|1,mid+1,r
#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 MEM(x,v) memset(x,v,sizeof(x))
inline int read(){
int x=0,f=0;char ch=getchar();
while(ch<'0' || ch>'9') f|=ch=='-',ch=getchar();
while(ch>='0' && ch<='9') x=x*10+ch-'0',ch=getchar();
return f?-x:x;
}
int n,a[maxn];
int gcd(int x,int y){return y?gcd(y,x%y):x;}
int main(){
n=read();
FOR(i,1,n) a[i]=read();
int t=0;
while(true){
int cnt1=0,cnte=0;
FOR(i,1,n){
if(a[i]==1) cnt1++;
if(a[i]%2==0) cnte++;
}
if(cnte!=n-1 || cnt1==1){puts(cnte%2?str[t]:str[t^1]);break;}
FOR(i,1,n) if(a[i]%2!=0){a[i]--;break;}
int g=0;
FOR(i,1,n) g=gcd(g,a[i]);
FOR(i,1,n) a[i]/=g;
t^=1;
}
}
// coming soon 2020.5.11 | 0 |
#include <iostream>
#include <cstring>
using namespace std;
class Dice {
public:
int a1, a2, a3, a4, a5, a6;
string D;
Dice(int x) {
a1 = a2 = a3 = a4 = a5 = a6 = x;
}
void rotateFront() {
int newa1 = a5;
a5 = a6;
a6 = a2;
a2 = a1;
a1 = newa1;
}
void rotateRight() {
int newa1 = a3;
a3 = a6;
a6 = a4;
a4 = a1;
a1 = newa1;
}
};
int main(void) {
Dice d1(0);
int i;
cin >> d1.a1 >> d1.a2 >> d1.a3 >> d1.a4 >> d1.a5 >> d1.a6;
cin >> d1.D;
for(i = 0; i < d1.D.size(); i++) {
if(d1.D[i] == 'S') {
d1.rotateFront();
} else if (d1.D[i] == 'N') {
d1.rotateFront();
d1.rotateFront();
d1.rotateFront();
} else if (d1.D[i] == 'W') {
d1.rotateRight();
} else if (d1.D[i] == 'E') {
d1.rotateRight();
d1.rotateRight();
d1.rotateRight();
}
}
cout << d1.a1 << endl;
return 0;
} | //#define _USE_MATH_DEFINES
#include <iostream>
//#include <stdio.h>
//#include <iomanip>
//#include <vector>
//#include <string>
//#include <algorithm>
//#include <functional>
//#include <cmath>
using namespace std;
class Dice
{
public:
Dice(int num[6]);
int Play(char c);
int T;
private:
int NS[4],EW[4];
int NS_p,EW_p;
};
//?????????????????????
Dice::Dice(int num[6])
{
NS_p = 0;
EW_p = 0;
NS[0] = num[0];
NS[1] = num[1];
NS[2] = num[5];
NS[3] = num[4];
EW[0] = num[0];
EW[1] = num[3];
EW[2] = num[5];
EW[3] = num[2];
T = num[0];
}
int Dice::Play(char c){
if (c == 'N' || c == 'S'){
if(c == 'N') NS_p = (NS_p + 1) % 4;
else {
if (NS_p == 0) NS_p = 3;
else NS_p--;
}
EW[EW_p] = NS[NS_p];
EW[(EW_p+2)%4] = NS[(NS_p+2)%4];
}
else if (c == 'E' || c == 'W'){
if (c == 'E') EW_p = (EW_p + 1) % 4;
else {
if (EW_p == 0) EW_p = 3;
else EW_p--;
}
NS[NS_p] = EW[EW_p];
NS[(NS_p + 2) % 4] = EW[(EW_p + 2) % 4];
}
T = NS[NS_p];
return 1;
}
int main(){
int num[6];
char c;
for (int i = 0; i < 6; i++){
cin >> num[i];
}
Dice d1(num);
while (cin >> c){
d1.Play(c);
}
cout << d1.T << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define mod 998244353
int f[12001];
int fi[12001];
int n, k;
int m(int a,int b){
return (a * b)% mod;
}
int fp(int x,int y) {
int res=1;
while(y){
if(y&1) res = res*x%mod;
x=x*x%mod;
y>>=1;
}
return res;
}
int iv(int x){
return fp(x, mod - 2);
}
int c(int x, int y){
// chon x tu y
return m(f[y],m(fi[x],fi[y - x]));
}
int ck(int x,int y){
// chia x keo cho y em
if(x < 0) return 0;
return c(y - 1 ,x + y - 1);
}
signed main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
f[0] = 1;
for(int i = 1 ; i <= 10000 ; i ++) f[i] = m(f[i - 1], i);
fi[10000] = iv(f[10000]);
for(int i = 9999 ; i >= 0 ; i --) fi[i] = m(fi[i + 1], (i + 1));
// int u,v;
// while(cin >> u >> v)
// cout << ck(u,v) << endl;
cin >> k >> n;
for(int i = 2 ; i <= k + k ; i ++){
int p = 0;
for(int j = 1 ; j <= k ; j ++){
int _j = i - j;
if(_j > 0 && _j != j && _j <= k) p ++;
}
p/= 2;
// cout << "#i = " << i << endl;
if(i % 2 == 1){
int ans = 0;
for(int q = 0; q <= p ; q ++){
// cout << "#q = " << q << endl;
// cout << "pair = " << c(q,p) << endl;
// cout << "n - q = " << n - q << endl;
// cout << "q + k - 2p = " << q + k - 2*p << endl;
// cout << "ck = " << ck(n - q, q + k - 2*p) << endl;
ans = (ans + m(m(c(q, p),fp(2,q)),ck(n - q, q + k - 2*p)))%mod;
}
cout << ans << endl;
} else{
int ans = 0;
for(int q = 0; q <= p ; q ++)
ans = (ans + m(m(c(q, p),fp(2,q)), ck(n - q - 1, q + k - 2*p - 1)))%mod;
for(int q = 0; q <= p ; q ++)
ans = (ans + m(m(c(q, p),fp(2,q)), ck(n - q , q + k - 2*p - 1)))%mod;
cout << ans << endl;
}
}
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9+7;
int main(){
int N,M; cin >> N >> M;
vector<ll> A(N),B(M);
map<ll,ll> mA,mB;
for(int i = 0; i < N; i++){ cin >> A[i]; mA[A[i]]++;}
for(int j = 0; j < M; j++){ cin >> B[j]; mB[B[j]]++;}
for(auto ne : mA){ if(ne.second>=2){ cout<< 0 << endl; return 0;}}
for(auto ne : mB){ if(ne.second>=2){ cout<< 0 << endl; return 0;}}
//以後、同じ数字はA,B内に複数回現れない
sort(A.begin(),A.end());
sort(B.begin(),B.end());
//でかい方から決めていく
ll ans = 1LL;
for(ll i = N*M; i >= 1; i--){
ll res1 = lower_bound(A.begin(),A.end(),i)-A.begin();
ll res2 = lower_bound(B.begin(),B.end(),i)-B.begin();
if( A[res1] == i && B[res2] == i){ //どちらにも含まれている時
continue;}
else if(A[res1] == i && B[res2] != i){
ans *= (M-res2);
ans %= MOD;
}
else if(A[res1] != i && B[res2] == i){
ans *= (N-res1);
ans %= MOD;
}
else{
if( (N-res1)*(M-res2) <= (N*M-i)){ ans = 0;}
ans *= ((N-res1)*(M-res2)-(N*M-i));
ans = (ans+MOD)%MOD;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cctype>
using namespace std;
namespace zyt
{
template<typename T>
inline bool read(T &x)
{
char c;
bool f = false;
x = 0;
do
c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF)
return false;
if (c == '-')
f = true, c = getchar();
do
x = x * 10 + c - '0', c = getchar();
while (isdigit(c));
if (f)
x = -x;
return true;
}
template<typename T>
inline void write(T x)
{
static char buf[20];
char *pos = buf;
if (x < 0)
putchar('-'), x = -x;
do
*pos++ = x % 10 + '0';
while (x /= 10);
while (pos > buf)
putchar(*--pos);
}
typedef long long ll;
const int N = 1e5 + 10;
int n, m, x[N], to[N], arr[N], id[N], ans[N];
ll k;
void trans(int *a, const int *b)
{
static int tmp[N];
for (int i = 1; i < n; i++)
tmp[i] = a[b[i]];
memcpy(a + 1, tmp + 1, sizeof(int[n - 1]));
}
int work()
{
read(n);
for (int i = 0; i < n; i++)
read(x[i]), id[i] = to[i] = i;
for (int i = n - 1; i > 0; i--)
x[i] -= x[i - 1];
read(m), read(k);
for (int i = 1; i <= m; i++)
read(arr[i]), --arr[i];
for (int i = 1; i <= m; i++)
swap(to[arr[i]], to[arr[i] + 1]);
while (k)
{
if (k & 1)
trans(id, to);
trans(to, to);
k >>= 1;
}
ll last;
write(last = x[0]), putchar('\n');
for (int i = 1; i < n; i++)
write(last += x[id[i]]), putchar('\n');
return 0;
}
}
int main()
{
return zyt::work();
} | #include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
#include <complex>
#include <cstdio>
#include <list>
//< in.txt > out.txt
using namespace std;
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
const long long MOD = 1e9 + 7;
typedef long long LL;
typedef long double LD;
typedef pair<LL, LL> PLL;
typedef pair<LD, LL> PDL;
typedef pair<LD, LD> PDD;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//typedef boost::multiprecision::cpp_int bigint;
template<class T>
void in(T& x) {
cin >> x;
}
template<class T1, class T2>
void in(pair<T1, T2>& p) {
in(p.first);
in(p.second);
}
template<class T>
void in(vector<T>& v, LL st = -1, LL en = -1) {
if (st == -1) {
st = 0;
en = v.size() - 1;
}
for (LL n = st; n <= en; n++) {
in(v[n]);
}
}
VLL mod(VLL& base, LL p) {
LL N = base.size();
if (p == 0) {
VLL res(N);
for (LL n = 0; n < N; n++)res[n] = n;
return res;
}
if (p == 1)return base;
VLL ret = mod(base, p / 2);
VLL res(N);
for (LL n = 0; n < N; n++) {
res[n] = ret[ret[n]];
}
if (p % 2 == 0)return res;
for (LL n = 0; n < N; n++) {
ret[n] = res[base[n]];
}
return ret;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
LL N, K,M;
cin >> N;
VLL X(N);
in(X);
VLL DX(N - 1);
for (LL n = 0; n < N - 1; n++) {
DX[n] = X[n + 1] - X[n];
}
cin >> M >> K;
VLL A(M);
in(A);
VLL P(N - 1);
for (LL n = 0; n < N-1; n++) {
P[n] = n;
}
for (LL m = 0; m < M; m++) {
LL n = A[m] - 1;
swap(P[n - 1], P[n]);
}
P = mod(P, K);
VLL res(N);
res[0] = X[0];
for (LL n = 1; n < N; n++) {
res[n] = res[n - 1] + DX[P[n-1]];
}
for (LL n = 0; n < N; n++) {
cout << res[n] << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define all(v) v.begin(), v.end()
#define sz(v) v.size()
#define INF 100000000000000 //10^14
template <typename T>
bool chmax(T &a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
vector<vector<vector<ll>>> dp(51, vector<vector<ll>>(51, vector<ll>(101, 0)));
int main()
{
ll N, K;
cin >> N >> K;
vector<ll> V(N);
rep(i, N) cin >> V.at(i);
ll ans = 0;
rep(l, min(N, K)+1){
rep(r, min(N, K)+1){
rep(d, l+r+1){
if(l+r+d > K){
continue;
}
if(l+r > N){
continue;
}
vector<ll> get(0);
rep(i, l){
get.push_back(V.at(i));
}
rep(i, r){
get.push_back(V.at(N-1-i));
}
sort(all(get));
get.erase(get.begin(), get.begin()+d);
ll tmp = 0;
rep(i, sz(get)){
tmp += get.at(i);
}
chmax(ans, tmp);
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>//Carefully Crafted by hetp111
using namespace std;
#define int long long
#define double long double
#define all(v) (v).begin(),(v).end()
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int,int>
#define vii vector<pii>
#define MOD 1000000007
#define MOD2 998244353
#define MOD3 1000000009
#define PI acos(-1)
#define eps (1e-8)
#define INF (1e18)
#define FASTER ios_base::sync_with_stdio(0);cin.tie(0)
template<class A,class B>ostream&operator<<(ostream&out,const pair<A,B>&a){return out<<"("<<a.first<<","<<a.second<<")";}
template<class A>ostream&operator<<(ostream&out,const vector<A>&a){for(const A &it:a)out<<it<<" ";return out;}
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}
//ifstream cinn("in.in");ofstream coutt("out.out");
int poww(const int &a,int b,const int &m=MOD){if(b==0)return 1;int x=poww(a,b/2,m);x=x*x%m;if(b&1)x=x*a%m;return x;}
int ceil(const int &a,const int &b){return (a+b-1)/b;}
////Read:
//Check corner cases, n==1;
//
////Some function:
//__builtin_popcountll(),
int n,c,dp[55][55][55][55];
vi v;
int f(int i,int cnt,int mxgap,int lst){
if(i==n){
mxgap=max(mxgap,i-lst-1);
if(cnt+(n-cnt-mxgap)*2<=c)return 0;
return -INF;
}
int &ans=dp[i][cnt][mxgap][lst+1];
if(ans!=-INF)return ans;
ans=v[i]+f(i+1,cnt+1,max(mxgap,i-lst-1),i);
ans=max(ans,f(i+1,cnt,mxgap,lst));
return ans;
}
signed main(){
FASTER;
cin>>n>>c;
v=vi(n);cin>>v;
for(int i=0;i<55;i++){
for(int j=0;j<55;j++){
for(int k=0;k<55;k++){
for(int l=0;l<55;l++){
dp[i][j][k][l]=-INF;
}
}
}
}
cout<<f(0,0,0,-1);
}
| 1 |
#include <cmath>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <vector>
#include <map>
#include<cstdio>
#include<functional>
#include <bitset>
#include <iomanip>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define repr(i, n) for(int i = n; i >= 0; i--)
#define ll long long
using namespace std;
template <typename T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
template <typename T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
const ll INF = 1000000000000000000;
const ll MOD = 1e9 + 7;
int gcd(int a, int b)
{
if (a%b == 0)
{
return(b);
}
else
{
return(gcd(b, a%b));
}
}
int lcm(int a, int b)
{
return a * b / gcd(a, b);
}
int main()
{
int n;
cin >> n;
vector<int> wl(n);
vector<int> el(n);
string s;
cin >> s;
rep(i, n) {
if (i - 1 >= 0) {
wl[i] = wl[i - 1];
el[i] = el[i - 1];
}
if (s[i] == 'W') {
wl[i]++;
}
else{
el[i]++;
}
}
int ans = 1000000000;
rep(i, n) {
int ec = 0;
int wc = 0;
if (i - 1 > 0) {
wc = wl[i - 1];
}
ec = el[el.size() - 1] - el[i];
ans = min(ans, ec + wc);
}
cout << ans << endl;
//cout << fixed << setprecision(10) << ans << endl;
system("pause");
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
int n;cin>>n;
string s;cin>>s;
int a[n+1],sum[n+1];
memset(a,0,sizeof(a));
memset(sum,0,sizeof(sum));
rep(i,n){
if(s[i]=='W'){
++a[i];
--a[n];
}
else{
++a[0];
--a[i+1];
}
}
sum[0]=a[0];
rep(i,n)sum[i+1]=a[i+1]+sum[i];
sort(sum,sum+n);
cout<<sum[0]-1<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
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 int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int K,T;
cin>>K>>T;
vector<int>a(T);
for(int i=0;i<T;i++){
cin>>a[i];
}
sort(a.rbegin(),a.rend());
int cnt=0;
for(int i=0;i<T;i++){
int cap=K-a[i];
cnt+=max(a[i]-1-cap,0);
}
cout<<cnt<<endl;
return 0;
} | // includes
#include "bits/stdc++.h"
using namespace std;
// macros
#define ll long long
#define MOD 998244353 //1000000007 // 100000000 //
#define pii pair<ll, ll>
#define piii pair<ll, pii>
#define sz(x) ((ll)(x).size())
#define ft first
#define sd second
#define pb push_back
#define rep(i, n) for(ll i = 0; i < n; i++)
#define repr(i, n) for(ll i = n-1; i >= 0; i--)
#define itr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define mem(a, b) memset(a, (ll)b, sizeof(a))
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define edge(v, x, y) v[x].pb(y); v[y].pb(x);
#define popc __builtin_popcount
#define ANS(s) {cout << s << "\n"; return;}
// functions
template <typename T> void unique(T& c){c.erase(std::unique(c.begin(), c.end()), c.end());}
template <class T>bool chmax(T &a, const T &b){if(a < b){a = b; return 1;} return 0;}
template <class T>bool chmin(T &a, const T &b){if(a > b){a = b; return 1;} return 0;}
template <typename T> istream &operator>>(istream &is, vector<T> &vec){for(auto &v: vec)is >> v; return is;}
template <typename T> ostream &operator<<(ostream &os, const vector<T>& vec){for(int i = 0; i < vec.size(); i++){ os << vec[i]; if(i + 1 != vec.size())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){os << "(" << p.first << ", " << p.second << ")"; return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << "(" << itr->first << ", " << itr->second << ")"; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << "(" << itr->first << ", " << itr->second << ")"; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
// constants
const ll N = 1e5+5;
const ll M = 1e6+5;
const ll A = 1e7+5;
const ll inf = 1e9;
const long long linf = 1LL << 60;
const double er = 1e-10;
const double pi = 3.141592653589793238463;
const ll lx[4] = {0, 1, -1, 0};
const ll ly[4] = {1, 0, 0, -1};
const ll dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const ll dy[8] = {1, -1, 0, 0, 1, 1, -1, -1};
// io
struct fast_io{
fast_io(){ios_base::sync_with_stdio(false); cin.tie(0); cout << fixed << setprecision(20);}
} fast_io_;
void solve()
{
ll n, m;
cin >> n >> m;
vector<ll> a(m); cin >> a;
sort(allr(a));
ll s = 0;
for(ll i = 1; i < m; i++) s += a[i];
if(s >= a[0]) ANS(0);
cout << a[0]-s-1;
}
int main(int argc, char const* argv[])
{
ll t = 1; //cin >> t;
while(t--) {
solve();
}
return 0;
}
| 1 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
string S;
cin>>S;
map<char, int> amap;
for(int i=0;i<S.size();++i) {
amap[S[i]]++;
}
if(S.size()<26) {
for(char i='a';i<='z';++i) {
if(amap[i]==0) {
S.push_back(i);
break;
}
}
cout<<S<<endl;
return 0;
}
else {
int num;
bool can = false;
vector<char> arr;
arr.push_back(S[S.size()-1]);
for(int i=S.size()-2;i>=0;--i) {
for(int j=0;j<arr.size();++j) {
if(S[i]<arr[j]) {
can = true;
num = S.size()-i;
S[i] = arr[j];
break;
}
}
if(can) break;
arr.push_back(S[i]);
sort(arr.begin(), arr.end());
}
if(!can) {
cout<<-1<<endl;
return 0;
}
for(int i=0;i<num-1;++i) S.pop_back();
cout<<S<<endl;
return 0;
}
}
| #include <iostream>
#include <iomanip>
#include<math.h>
#include<list>
#include <algorithm>
#include<set>
#include<vector>
#include<math.h>
#include<map>
#include<string>
#include <numeric>
#include <queue>
#include <sstream>
#include <bitset>
#include<stack>
using namespace std;
using ll = long long;
using vll = vector<long long>;
using sll = set<long long>;
template<typename T>
T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<typename T>
map<T, T> getPrimeFactor(T n) {
map<T, T> res;
for (T i = 2; i * i <= n; ++i) {
while (n % i == 0) {
res[i] ++;
n /= i;
}
}
if (n != 1) res[n] = 1;
return res;
}
template<typename T>
bool IsPrimeNumber(T num)
{
if (num <= 2) return true;
else if (num % 2 == 0) return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return false;
}
}
return true;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// 繰り返し二乗法
ll pow2(ll n, ll p, ll mod) {
if (p == 0 || n == 1) {
return 1;
}
else {
ll ret = pow2(n * n % mod, p / 2, mod);
if (p % 2 == 1) {
ret *= n;
}
return ret % mod;
}
}
#define rep(i,s,e) for(ll i=s;i<e;i++)
#define repeq(i,s,e) for(ll i=s;i<=e;i++)
int main() {
string S;
cin >> S;
vector<set<char>> vs(S.size()+1);
rep(i, 0, S.size()) {
vs[i + 1] = vs[i];
vs[i+1].insert(S[i]);
}
char next = 'a'-1;
for (ll i = S.size(); i >=0; i--) {
for (char c = next+1; c <= 'z'; c++) {
if (vs[i].find(c) == vs[i].end()) {
cout << S.substr(0,i) << c << endl;
return 0;
}
}
next = S[i - 1];
}
cout << -1 << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define ll long long
#define rep(i,n) for(int i = 0; i < int(n); i++)
#define vi vector<int>
using namespace std;
const int INF = 1001001001;
const int MOD = 1e9+7;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
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; }
int main(){
cin.tie(0), ios::sync_with_stdio(false);
int n,m,d; cin >> n >> m >> d;
if(d) cout << setprecision(10) << 2.0*(n-d)/n/n*(m-1);
else cout << setprecision(10) << 1.0/n*(m-1);
cout << "\n";
return 0;
}
| #include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
int main() {
string sa, sb, sc; cin >> sa >> sb >> sc;
char nx = 'a';
while (true) {
if (nx == 'a') {
if (sa.size() == 0) {
cout << "A" << endl;
return 0;
}
nx = sa[0];
sa = sa.substr(1, sa.size()-1);
} else if (nx == 'b') {
if (sb.size() == 0) {
cout << "B" << endl;
return 0;
}
nx = sb[0];
sb = sb.substr(1, sb.size()-1);
} else {
if (sc.size() == 0) {
cout << "C" << endl;
return 0;
}
nx = sc[0];
sc = sc.substr(1, sc.size()-1);
}
}
return 0;
} | 0 |
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };
ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
int main() {
for (;;) {
int N, Q; cin >> N >> Q;
if (N == 0 && Q == 0) break;
vector<int> a(100);
while (N--) {
int M; cin >> M;
while (M--) {
int i; cin >> i;
a[i]++;
}
}
int _i = 0; Q--;
for (int i = 1; i < 100; i++)
if (a[i] > Q) {
_i = i;
Q = a[i];
}
cout << _i << endl;
}
} | #include<vector>
using namespace std;
int N, Q;
int num[110];
int mnum, mday;
int main(){
while(cin>>N>>Q, N||Q){
for(int i = 0; i < 110; i++)num[i] = 0;
for(int n = 0; n < N; n++){
int M;
cin>>M;
for(int m = 0; m < M; m++){
int tmp;
cin>>tmp;
num[tmp] += 1;
}
}
int i;
mday = 110, mnum = 0;
for(i = 0; i < 110; i++){
if(num[i] >= Q ){
if(mnum < num[i]){
mnum = num[i];
mday = i;
}
}
}
cout<<(mnum?mday:0)<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
template<typename T, typename U>
using pv=vector<pair<T,U>>;
template<typename T>
using matrix=vector<vector<T>>;
template<typename T>
using pque=priority_queue<T>;
template<typename T>
using lpque=priority_queue<T,vector<T>,greater<T>>;
using ll=long long;
using intpair=pair<int,int>;
using llpair=pair<ll,ll>;
using ilpair=pair<int,ll>;
using lipair=pair<ll,int>;
using intvec=vector<int>;
using llvec=vector<ll>;
using intq=queue<int>;
using llq=queue<ll>;
using intmat=vector<intvec>;
using llmat=vector<llvec>;
#define PI 3.141592653589793
#define INTINF 1<<30
#define LLINF 1LL<<60
#define MPRIME 1000000007
#define MPRIME9 998244353
#define MMPRIME (1ll<<61)-1
#define len length()
#define pushb push_back
#define fi first
#define se second
#define setpr fixed<<setprecision(15)
#define all(name) name.begin(),name.end()
#define rall(name) name.rbegin(),name.rend()
#define gsort(vbeg,vend) sort(vbeg,vend,greater<>())
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;
}
template<class T>
inline void outmat(T& a, int y, int x) {
for(int i=0; i<y; i++) {
for(int j=0; j<x; j++) cout<<a[i][j]<<" ";
cout<<endl;
}
}
template<class T>
inline void init(T& v) {
for(auto &a: v) cin>>a;
}
template<class T, class U>
inline void init(vector<pair<T,U>>& v) {
for(auto &a: v) cin>>a.first>>a.second;
}
template<class T, class N>
inline void init(T& v, N n) {
v.resize(n);
for(auto &a: v) cin>>a;
}
template<class T, class U, class N>
inline void init(vector<pair<T,U>>& v, N n) {
v.resize(n);
for(auto &a: v) cin>>a.first>>a.second;
}
template<class N>
void resiz(N n) {
//empty
}
template<class N, class T, class... U>
void resiz(N n, T&& hd, U&&... tl) {
hd.resize(n);
resiz(n,forward<U>(tl)...);
}
ll binpow(ll a, ll ex, ll p) { //繰り返し二乗法
ll result=1;
while(ex>0) {
if(ex&1) result=result*a%p;
ex>>=1;
a=a*a%p;
}
return result;
}
string S;
int alp[26];
void input() {
cin>>S;
}
void solve() {
ll res=(ll)S.len*(S.len-1)/2+1;
for(int i=0; i<S.len; i++) {
res-=alp[S[i]-'a'];
alp[S[i]-'a']++;
}
cout<<res<<endl;
}
int main() {
int t=1;
while(t) {
input();
solve();
t--;
}
}
|
#include<iostream>
#include<vector>
using namespace std;
int foot(int);
int main() {
int n;
vector<int>floor;
cin >> n;
while (n != 0) {
floor.push_back(n);
cin >> n;
}
floor.push_back(0);
int i = 0;
while (floor[i] != 0) {
int res = 0;
res = foot(floor[i]) / 3650;
if( foot(floor[i]) % 3650 != 0) res++;
cout << res << endl;
i++;
}
cin >> n;
return 0;
}
int foot(int n) {
if (n == 1)return 1;
if (n == 2)return 2;
if (n == 3)return 4;
if (n < 1)return 0;
return foot(n - 1) + foot(n - 2) + foot(n - 3);
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 25;
const int MOD = 1e9+7;
int main() {
string x;
cin >> x;
int n = x.size();
stack<char> s;
int cnt = 0;
rep(i,n) {
if (x[i] == 'S') s.push(x[i]);
if (x[i] == 'T' && s.empty()) s.push(x[i]);
if (x[i] == 'T' && s.top() == 'S') {
s.pop();
cnt += 2;
}
}
cout << n-cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
typedef vector < vector<ll> > Mat;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
bool ans[60];
int main(){
ll N; cin >> N;
for (int i = 0; i < 60; i++){
ll now = (ll) 1 << (i + 1);
if (N % now != 0){
ans[i] = true;
if (i % 2 == 0) N -= now / 2;
else N += now / 2;
}
if (N == 0){
for (int j = i; j >= 0; j--) cout << ans[j];
cout << endl;
return 0;
}
}
return 0;
}
| 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;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
const ll LINF = 2e18;
const int INF = 1e9;
void solve(ll sx, ll sy, ll tx, ll ty) {
ll dx = tx - sx;
ll dy = ty - sy;
cout << string(dy, 'U') << string(dx, 'R');
cout << string(dy, 'D') << string(dx, 'L');
cout << 'L' << string(dy + 1, 'U') << string(dx + 1, 'R') << 'D';
cout << 'R' << string(dy + 1, 'D') << string(dx + 1, 'L') << 'U';
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll sx;
scanf("%lld", &sx);
ll sy;
scanf("%lld", &sy);
ll tx;
scanf("%lld", &tx);
ll ty;
scanf("%lld", &ty);
solve(sx, sy, tx, ty);
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int sx, sy, tx, ty; cin >> sx >> sy >> tx >> ty;
for (int i = 0; i < ty-sy; i++)
cout << 'U';
for (int i = 0; i < tx-sx; i++)
cout << 'R';
for (int i = 0; i < ty-sy; i++)
cout << 'D';
for (int i = 0; i < tx-sx; i++)
cout << 'L';
cout << 'L';
for (int i = 0; i <= ty-sy; i++)
cout << 'U';
for (int i = 0; i <= tx-sx; i++)
cout << 'R';
cout << 'D';
cout << 'R';
for (int i = 0; i <= ty-sy; i++)
cout << 'D';
for (int i = 0; i <= tx-sx; i++)
cout << 'L';
cout << 'U' << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <cstdlib> //abs()で絶対値を取得する（整数）
#include <cmath> //abs()かfabs()で絶対値を取得する（少数）
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
int main(){
int n, r;
cin >> n >> r;
if (n >= 10){
cout << r << endl;
}else{
int ans = 100 * (10 - n) + r;
cout << ans << endl;
}
} | // In The Name Of Allah
#include <bits/stdc++.h>
#define ss second
#define ff first
#define use_fast ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define ret(n) return cout << n, 0
#define se(n) cout << setprecision(n) << fixed
#define pb push_back
#define int long long
#define ld long double
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int N = 4e6 + 100, T = 2e3 + 100, OO = 1e12 + 10, M = 1e9 + 7, P = 49157, sq = 360, lg = 30;
typedef pair <int, int> pii;
int dp[T][T];
int fac[N], inv[N];
int pw(int x, int y) {
if(y == 0)
return 1;
int cnt = pw(x, y / 2);
cnt = (cnt * cnt) % M;
cnt = (cnt * (y % 2 == 1 ? x : 1)) % M;
return cnt;
}
void prepro() {
fac[0] = 1;
for(int i = 1; i <= N - lg; i++)
fac[i] = (fac[i - 1] * i) % M;
inv[N - lg] = pw(fac[N - lg], M - 2);
for(int i = N - lg - 1; i > -1; i--)
inv[i] = (inv[i + 1] * (i + 1)) % M;
}
int c(int x, int y) {
if(x == y || y == 0)
return 1;
return ((fac[x] * inv[y] % M) * inv[x - y]) % M;
}
int32_t main() {
use_fast;
prepro();
int n, k;
cin >> n >> k;
if(k == 1)
return cout << 1, 0;
dp[0][0] = 1;
for(int i = 1; i <= n; i++) {
for(int j = i; j >= 1; j--)
dp[i][j] = (dp[i][j + 1] + (dp[i - 1][j - 1] * i) % M * c(i * k - 1 - j, k - 2)) % M;
dp[i][0] = dp[i][1];
}
cout << dp[n][0] << endl;
return 0;
}
/*
be carefull :
1- if not solve after 20 min, read again twice
2- after submit read the code again
3- fun with contest
4- ...
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAX = 1000001;
const int MOD = 1000000007;
signed main() {
int n;
cin>>n;
int a[n],b[n];
for(int i=0;i<n;i++)cin>>a[i];
for(int i=0;i<n;i++)cin>>b[i];
int x[3*n],y[3*n];
for(int i=0;i<n;i++)x[i]=b[i%n]^(b[(i+1)%n]);
for(int i=0;i<n;i++){
x[i+n]=a[i%n]^a[(i+1)%n];
x[i+2*n]=a[i%n]^a[(i+1)%n];
}
y[0] = 3*n;
int i = 1, j = 0;
while (i < 3*n) {
while (i+j < 3*n && x[j] == x[i+j]) ++j;
y[i] = j;
if (j == 0) { ++i; continue;}
int k = 1;
while (i+k < 3*n && k+y[k] < j) y[i+k] = y[k], ++k;
i += k; j -= k;
}
for(int i=n;i<2*n;i++){
if(y[i]>=n)cout<<i-n<<' '<<(a[i-n]^b[0])<<endl;
}
return 0;
}
| /*
Author:zeke
pass System Test!
GET AC!!
*/
#include <iostream>
#include <queue>
#include <vector>
#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <algorithm>
#include <functional>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <map>
#include <iomanip>
#include <utility>
#include <stack>
#include <bitset>
using ll = long long;
using ld = long double;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define rep3(var, min, max) for (ll(var) = (min); (var) < (max); ++(var))
#define repi3(var, min, max) for (ll(var) = (max)-1; (var) + 1 > (min); --(var))
#define Mp(a, b) make_pair((a), (b))
#define F first
#define S second
#define Icin(s) \
ll(s); \
cin >> (s);
#define Scin(s) \
ll(s); \
cin >> (s);
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 pair<ll, ll> P;
typedef vector<ll> V;
typedef vector<V> VV;
typedef vector<P> VP;
//ll mod = 1e9 + 7;
//ll MOD = 1e9 + 7;
ll INF = 1e18;
struct RollingHash
{
typedef long long lint;
const string str;
const lint base, mod;
const V tempvec;
vector<lint> hash, pw;
RollingHash(V &s, lint h = 1000000007, lint b = 1009) : tempvec(s), mod(h), base(b)
{
int l = s.size();
hash.assign(l + 1, 0);
pw.assign(l + 1, 0);
pw[0] = 1;
for (int i = 0; i < l; ++i)
{
pw[i + 1] = pw[i] * base % mod;
hash[i + 1] = (hash[i] * base + s[i]) % mod;
}
}
lint const get_hash(int l, int r)
{
return ((hash[r] - hash[l] * pw[r - l]) % mod + mod) % mod;
}
};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
V Vec1(n);
rep(i, n) cin >> Vec1[i];
V Vec2(n);
rep(i, n) cin >> Vec2[i];
V vec1(n);
V vec2(n);
rep(i, n)
{
vec1[i] = Vec1[i] ^ Vec1[(i + 1) % n];
vec2[i] = Vec2[i] ^ Vec2[(i + 1) % n];
}
rep(i,n){
vec1.push_back(vec1[i]);
}
RollingHash tree(vec1, 1e9 + 7, 1e3 + 7);
RollingHash tree2(vec1, 999999937, 1e3 + 7);
RollingHash tree5(vec1, 1000000033, 1e3 + 7);
RollingHash tree3(vec2, 1e9 + 7, 1e3 + 7);
RollingHash tree4(vec2, 999999937, 1e3 + 7);
RollingHash tree6(vec2, 1000000033, 1e3 + 7);
VP res;
// cout<<s<<" "<<t<<endl;
rep(i, n)
{
ll s_hash = tree.get_hash(i, i + n);
ll t_hash = tree3.get_hash(0, n);
ll s_hash2 = tree2.get_hash(i, i + n);
ll t_hash2 = tree4.get_hash(0, n);
ll s_hash3 = tree5.get_hash(i, i + n);
ll t_hash3 = tree6.get_hash(0, n);
if (s_hash == t_hash && s_hash2 == t_hash2 && s_hash3 == t_hash3)
{
res.push_back({i, Vec1[i] ^ Vec2[0]});
}
}
rep(i, res.size())
{
cout << res[i].F << " " << res[i].S << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int h, w;
int grid[20][20];
int sx, sy, gx, gy;
bool ok(int x, int y)
{
return x >= 0 && y >= 0 && x < h && y < w;
}
bool search(int d, int x, int y)
{
if (d == 0){
return x == gx && y == gy;
}
for (int dir = 0; dir < 4; dir++){
int k = 0;
while (true){
int nx = x + dx[dir] * k;
int ny = y + dy[dir] * k;
int nnx = nx + dx[dir];
int nny = ny + dy[dir];
if (!ok(nx, ny)) break;
if (grid[nx][ny] == 3){
return true;
}
if (!ok(nnx, nny)) break;
if (grid[nnx][nny] == 1){
if (k == 0) break;
grid[nnx][nny] = 0;
if (search(d - 1, nx, ny)){
grid[nnx][nny] = 1;
return true;
}
grid[nnx][nny] = 1;
break;
}
k++;
}
}
return false;
}
int solve()
{
for (int d = 1; d <= 10; d++){
if (search(d, sx, sy)){
return d;
}
}
return -1;
}
int main()
{
while (scanf("%d %d", &w, &h), w){
fill_n(*grid, 20 * 20, 0);
for (int i = 0; i < h; i++){
for (int j = 0; j < w; j++){
scanf("%d", &grid[i][j]);
if (grid[i][j] == 2){
sx = i;
sy = j;
}
else if (grid[i][j] == 3){
gx = i;
gy = j;
}
}
}
printf("%d\n", solve());
}
return 0;
} | #include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n, m;
int veg[1024];
int sum;
while (1){
sum = 0;
scanf("%d%d", &n, &m);
if (n == 0 && m == 0){
break;
}
for (int i = 0; i < n; i++){
scanf("%d", &veg[i]);
}
sort(veg, veg + n);
reverse(veg, veg + n);
for (int i = 0; i < n; i++){
if ((i + 1) % m != 0){
sum += veg[i];
}
}
cout << sum << endl;
}
return (0);
} | 0 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for(int(i) = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for(int(i) = (m); (i) < (n); (i)++)
#define All(v) (v).begin(), (v).end()
#define pb push_back
#define MP(a, b) make_pair((a), (b))
typedef long long ll;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int MOD = 1e9 + 7;
bool check(string s, vector<char> &res, char c1, char c2) {
res[0] = c1, res[1] = c2;
int n = s.size();
for(int i = 1; i < s.size() - 1; i++) {
if(s[i] == 'o' && res[i] == 'S')
res[i + 1] = res[i - 1];
else if(s[i] == 'o' && res[i] == 'W')
res[i + 1] = (res[i - 1] == 'W' ? 'S' : 'W');
else if(s[i] == 'x' && res[i] == 'S')
res[i + 1] = (res[i - 1] == 'W' ? 'S' : 'W');
else if(s[i] == 'x' && res[i] == 'W')
res[i + 1] = res[i - 1];
}
bool ret = false;
if((res[0] == 'W' && s[0] == 'o') || (res[0] == 'S' && s[0] == 'x')) {
ret = !(res[1] == res[s.size() - 1]);
if((res[n - 1] == 'W' && s[n - 1] == 'o') ||
(res[n - 1] == 'S' && s[n - 1] == 'x')) {
ret &= !(res[0] == res[n - 2]);
} else {
ret &= (res[0] == res[n - 2]);
}
return ret;
} else {
ret = (res[1] == res[s.size() - 1]);
if((res[n - 1] == 'W' && s[n - 1] == 'o') ||
(res[n - 1] == 'S' && s[n - 1] == 'x')) {
ret &= !(res[0] == res[n - 2]);
} else {
ret &= (res[0] == res[n - 2]);
}
return ret;
}
}
int main() {
int N;
string s;
cin >> N;
cin >> s;
vector<char> res(N);
if(check(s, res, 'S', 'S')) {
rep(i, N) cout << res[i];
cout << endl;
return 0;
}
if(check(s, res, 'S', 'W')) {
rep(i, N) cout << res[i];
cout << endl;
return 0;
}
if(check(s, res, 'W', 'S')) {
rep(i, N) cout << res[i];
cout << endl;
return 0;
}
if(check(s, res, 'W', 'W')) {
rep(i, N) cout << res[i];
cout << endl;
return 0;
}
cout << -1 << endl;
return 0;
} | #include<iostream>
#include<string>
#include<map>
using namespace std;
int main() {
map <char, int> a;
a.insert(map<char, int>::value_type('I', 1));
a.insert(map<char, int>::value_type('V', 5));
a.insert(map<char, int>::value_type('X', 10));
a.insert(map<char, int>::value_type('L', 50));
a.insert(map<char, int>::value_type('C', 100));
a.insert(map<char, int>::value_type('D', 500));
a.insert(map<char, int>::value_type('M', 1000));
string c;
while (cin >> c) {
string d="";
for (int i = c.length() - 1; i >= 0; i--)
d += c[i];
int sum = 0, e = 0;
for (int i = 0; i < c.length(); i++) {
if (a[d[i]] >= e) {
sum += a[d[i]];
e = a[d[i]];
}
else {
sum -= a[d[i]];
}
}
cout << sum << endl;
}
} | 0 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ll n,i,j,c,d,an=0,k,mod;
mod=1000000007;
cin>>n;
ll ar[n+2];
for(i=0;i<n;i++)
{
cin>>ar[i];
}
for(i=0;i<60;i++)
{
k=(1LL<<i);
c=0;
d=0;
for(j=0;j<n;j++)
{
if((ar[j] & k)==0)
c++;
else
d++;
}
an=an+((k%mod)*((c*d)%mod))%mod;
an=an%mod;
}
cout<<an<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define F first
#define S second
const int sz = 1e5+5;
int n, m, a[sz];
void solve(){
cin >> n >> m;
for(int i = 0; i < n; ++i) cin >> a[i];
ll ans = 0;
map<int, int> cnt;
cnt[0] = 1;
int sum = 0;
for(int i = 0; i < n; ++i){
sum = (sum + a[i]) % m;
ans += cnt[sum];
cnt[sum]++;
}
cout << ans << '\n';
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
} | 0 |
//list index out of rangeエラー表示用
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep1(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int x;
cin >> x;
int c500 = 500;
int c5 = 5;
int ans = (x / 500) * 1000 + ((x % 500) / 5) *5;
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep1(i, n) for(int i = 1; i <= (int)(n); i++)
#define showmap(is, js, x) {rep(i, is){rep(j, js){cout << x[i][j] << " ";}cout << endl;}}
#define show(x) {for(auto i: x){cout << i << " ";} cout<<endl;}
#define showm(m) {for(auto i: m){cout << m.x << " ";} cout<<endl;}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
ll gcd(int x, int y){ return y?gcd(y, x%y):x;}
ll lcm(ll x, ll y){ return (x*y)/gcd(x,y);}
int main()
{
string s;
cin >> s;
map<int, int> num;
ll ans = 0;
rep(i, s.size()){
if (num.find(s[i]-'a') == num.end()){
num.insert({s[i]-'a', 1});
} else {
num[s[i]-'a']++;
}
ans += i+1-num[s[i]-'a'];
}
cout << ans+1 << endl;
}
| 0 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
template<class T> ostream& operator<<(ostream& os, const vector<T>& vec) { for (auto &vi: vec) os << vi << " "; return os; }
int main() {
vector<int> ab(2);
for (auto &abi: ab) cin >> abi;
int k; cin >> k;
for (int i = 0; i < k; i++) {
ab[(i & 1) ^ 1] += ab[i & 1] >>= 1;
}
cout << ab << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
int n, a;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++)
{
cin >> a;
v.push_back(a);
}
reverse(v.begin(), v.end());
for (int i = 0; i < n - 1; i++)
{
cout << v[i] << " ";
}
cout << v[n - 1] << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for(ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const double PI=acos(-1);
template<typename T>
istream& operator>> (istream& is, vector<T> &vec){
for(T& x: vec) is >> x;
return is;
}
int main(){
string s; cin >> s;
ll length = s.length();
reverse(s.begin(), s.end());
ll tcnt = 0;
rep(i, s.length()){
if(s[i] == 'S') {
if(tcnt > 0){
length -= 2;
tcnt--;
}
}else{
tcnt++;
}
}
cout << length << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int N; cin >> N;
long long x; cin >> x;
vector<long long> a(N);
for (int i = 0; i < N; ++i) cin >> a[i];
sort(a.begin(), a.end());
int res = 0;
for (int i = 0; i < N; ++i) {
if (x >= a[i]) ++res, x -= a[i];
else break;
}
if (res == N && x) --res;
cout << res << endl;
} | 0 |
#include <iostream>
using namespace std;
long gcd(long a, long b){ return b? gcd(b,a%b) : a; }
int main() {
int n,k;
cin >> n >> k;
long GCD;
cin >> GCD;
long _max = GCD;
bool f = k == GCD;
for (int i=1; i<n; i++) {
long a;
cin >> a;
f = f || k==a;
GCD = gcd(GCD, a);
_max = max(_max, a);
}
if (f || (k%GCD==0 && k <= _max)) {
cout << "POSSIBLE" << endl;
} else {
cout << "IMPOSSIBLE" << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for(int(i) = (int)(m); i < (int)(n); ++i)
#define rep2(i, m, n) for(int(i) = (int)(n)-1; i >= (int)(m); --i)
#define REP(i, n) rep(i, 0, n)
#define REP2(i, n) rep2(i, 0, n)
#define all(hoge) (hoge).begin(), (hoge).end()
#define en '\n'
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
typedef pair<ll, ll> P;
constexpr long long INF = 1LL << 60;
constexpr int INF_INT = 1 << 25;
constexpr long long MOD = (ll)1e9 + 7;
//constexpr long long MOD = 998244353LL;
using ld = long double;
static const ld pi = 3.141592653589793L;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
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;
}
struct Edge {
ll to, rev;
long double cap;
Edge(ll _to, long double _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
void add_edge(Graph &G, ll from, ll to, long double cap, bool revFlag,
long double revCap) {
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if(revFlag)
G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
}
void solve() {
ll n, k;
cin >> n >> k;
vec<ll> a(n);
ll d = 0;
REP(i, n) {
cin >> a[i];
d = gcd(d, a[i]);
}
REP(i, n) {
if(a[i] < k)
continue;
if((k - a[i]) % d)
continue;
cout << "POSSIBLE" << en;
return;
}
cout << "IMPOSSIBLE" << en;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
/*
ll t;
cin >> t;
REP(i, t) { solve(); }*/
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ran 1001001
struct Node {
int pre, det, suf;
Node() {}
} info[ran];
int n;
char s[ran];
Node analysis() {
int len = strlen(s);
int h = 0;
int mi = 0;
for(int i=0;i<len;i++) {
if(s[i]=='(') h++;
else h--;
mi = min(mi, h);
}
Node res;
res.pre = -mi;
res.det = h;
res.suf = res.pre + res.det;
return res;
}
int cmp(const Node &a, const Node &b) {
bool fa = (a.det>=0), fb = (b.det>=0);
if(fa!=fb) return fa;
if(fa) return a.pre<b.pre;
return a.suf > b.suf;
}
bool chk() {
int sum = 0;
for(int i=0;i<n;i++)
sum += info[i].det;
if(sum!=0) return false;
sort(info, info+n, cmp);
int cur = 0;
for(int i=0;i<n;i++) {
if(cur<info[i].pre) return false;
cur += info[i].det;
}
return true;
}
int main() {
scanf("%d", &n);
for(int i=0;i<n;i++) {
scanf("%s", s);
info[i] = analysis();
}
puts(chk() ? "Yes" : "No");
return 0;
} | #include<iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
int main(){
int n,i,j,k,p,count=0;
set<int>::iterator it;
vector<int>x,y;
cin>>n;
for(i=0;i<n;i++){
cin>>p;
x.push_back(p);
}
sort(x.begin(),x.end());
for(i=0;i<n;i++){
if(x[i]==x[i+1]){
x[i]=0;
x[i+1]=0;
}
}
for(i=0;i<n;i++){
if(x[i]!=0){
count++;
}
}
cout<<count;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool ok = true;
if (S.size() % 2 == 1) ok = false;
for (int i = 0; i < S.size() / 2; i += 2) {
if (S.substr(i, 2) != "hi") {
ok = false;
}
}
if(ok) cout << "Yes" << endl;
else cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int main() {
string s;
cin >> s;
if(s[0] != 'A' || isupper(s[1]) || isupper(s[s.size() - 1])){
cout << "WA" << endl;
return 0;
}
bool isFoundC = false;
for(int i = 2; i < s.size() - 1; i++){
if(!isFoundC && s[i] == 'C') isFoundC = true;
else if(s[i] == 'C'){
cout << "WA" << endl;
return 0;
}else if(isupper(s[i])){
cout << "WA" << endl;
return 0;
}
}
cout << (isFoundC ? "AC" : "WA") << endl;
}
| 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;
//datatypes
#define ll long long
#define vi vector<int>
#define vll vector<ll>
#define si set<int>
#define vii vector<ii>
#define ii pair<int,int>
#define vpll vector<pll>
#define pii pair<int,int>
#define pll pair<ll, ll>
#define mii map<int,int>
#define ord_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define M 1000000007
#define narak 998244353
#define pi acos(-1)
#define inf 2147483647
#define infl 9223372036854775807
#define infd 1.7e308
#define invd 1.7e-308
#define sz(x) (ll)x.size()
#define fr first
#define sc second
#define pb push_back
#define mkp make_pair
#define rep(i,a,b) for(int i=a; i<b; ++i)
#define rep0(i,a) for(int i=0; i<a; ++i)
#define rep1(i,a) for(int i=1; i<=a; ++i)
#define trav(a) for(auto &x:a)
#define test cout<<"hello\n";
#define all(x) (x).begin(),(x).end()
#define mem(x,val) memset(x, val, sizeof(x))
#define sa(x) std::sort(all(x))
#define endl '\n'
#define __lcm(m,n) m*(n/__gcd(m,n))
#define fill(a,n) for(int xxx=0;xxx<n;++xxx) cin>>(a)[xxx]
#define maxa(v) *(max_element(all(v)))
#define mina(v) *(min_element(all(v))
#define inputFile freopen("input.txt", "r", stdin);
#define outputFile freopen("output.txt", "w", stdout);
#define disp(a) trav(a) cout<<x<<" "; cout<<endl;
//#define int long long
template<typename T, typename U> static inline void amin(T &x, U y){ if(y<x) x=y; }
template<typename T, typename U> static inline void amax(T &x, U y){ if(x<y) x=y; }
template<typename T,typename U> std::ostream& operator<<(std::ostream& out, std::pair<T,U> a) {out<<a.fr<<" "<<a.sc; return out;}
template<typename T,typename U> std::istream& operator>>(std::istream& in, std::pair<T,U> &a) {in>>a.fr>>a.sc; return in;}
template<typename T> static inline void sd(vector<T> &x) {sort(all(x), greater<T>()) ; }
const int N=301;
int n;
double dp[N][N][N]={};
signed solve()
{
cin>>n;
int cnt[4]={};
rep(i,0,n){int x;
cin>>x;
cnt[x]++;
}
dp[0][0][0]=0;
for(int three=0; three<=n; ++three)
{
for(int two=0; two<=n; ++two)
{
for(int one=0; one<=n; ++one)
{
int zero = n -(three+two+one);
if(zero == n)
continue;
if(three+two+one > n)
continue;
double val = 1;
if(three>0)
val += (1.0*three/n)*(dp[three-1][two+1][one]);
if(two>0)
val += (1.0*two/n)*(dp[three][two-1][one+1]);
if(one>0)
val += (1.0*one/n)*(dp[three][two][one-1]);
val /= (1.0-1.0*zero/n);
dp[three][two][one] = val;
}
}
}
cout<<fixed<<setprecision(12)<<dp[cnt[3]][cnt[2]][cnt[1]];
return 0;
}
signed main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t=1;
//cin>>t;
while(t--)
{
solve();
}
//cout << "\nTime : " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MX = 400;
int h, w;
string s;
int grid[MX][MX];
ll black[MX*MX], white[MX*MX];
bool used[MX][MX];
ll ans;
int curGroup = -1;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
void dfs(int x, int y) {
used[x][y] = true;
if (grid[x][y]) black[curGroup]++;
else white[curGroup]++;
for (int i = 0; i < 4; i++) {
int a = x + dx[i], b = y + dy[i];
if (a < 0 || a >= h || b < 0 || b >= w) continue;
if (grid[a][b] == grid[x][y]) continue;
if (used[a][b]) continue;
dfs(a, b);
}
}
int main() {
cin.sync_with_stdio(0); cin.tie(0);
cin >> h >> w;
for (int i = 0; i < h; i++) {
cin >> s;
for (int j = 0; j < w; j++) {
if (s[j] == '#') grid[i][j] = 1;
else grid[i][j] = 0;
}
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
curGroup++;
if (!used[i][j]) dfs(i, j);
}
}
for (int i = 0; i <= curGroup; i++) {
ans += white[i] * black[i];
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define F first
#define S second
#define sz(x) (int)x.size()
#define all(x) (x).begin(), (x).end()
#define Red ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define rep(i, n) for(int i =0 ; i < n; ++i)
#define pii pair < int, int >
typedef vector<int> vi;
typedef long long ll;
const int mod =1e9+7;
void solve(){
int a,b;
cin>>a>>b;
if(a>8 || b>8)cout<<":(";
else cout<<"Yay!";
}
int main(){
Red;
int t=1;
//cin>>t;
while(t--)
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
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 int INF=1001001001;
const int mod=1e9+7;
int main(){
int N,K;
cin>>N>>K;
vector<char>D(K);
for(int i=0;i<K;i++){
cin>>D[i];
}
for(int i=N;;i++){
string t=to_string(i);
bool use=true;
for(int k=0;k<t.size();k++){
bool ok=true;
for(int j=0;j<K;j++){
if(t[k]==D[j]){
ok=false;
}
}
if(!ok){use=false;}
}
if(use){cout<<t<<endl;return 0;}
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main() {
int a;
cin >> a;
int res = 0;
for (int i = 0; i < 3; ++i) res = (res + 1) * a;
cout << res << endl;
}
| #include<bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
#define RREP(i,n) for(int i=n;i>=0;i--)
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
typedef long long ll;
int main(void){
int a;
cin >> a;
cout << a+a*a+a*a*a << endl;
return 0;
} | 1 |
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
int a[100][100];
bool r[100];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin>>n;
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
cin>>a[i][j];
}
}
priority_queue<pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > >q;
q.push(make_pair(0,0));
int cost=0;
pair<int,int> e;
while(!q.empty()) {
e=q.top();
q.pop();
if(r[e.second]) continue;
r[e.second]=true;
cost+=e.first;
for(int i=0; i<n; i++) {
if(a[e.second][i]!=-1) q.push(make_pair(a[e.second][i], i));
}
}
cout<<cost<<'\n';
return 0;
} | #include<iostream>
using namespace std;
#define N 105
#define INF 1<<21
int n;
int a[N][N];
int d[N],p[N],color[N]; //0.未访问的节点 1.正在访问的节点 2.已经访问过的节点
int prim(){
int u ,minv;
for (int i = 0;i < n;i++){
d[i] = INF;
p[i] = -1;
color[i] = 0;
}
d[0] = 0;
while (1){
minv = INF;
u = -1;
for (int i = 0;i < n;i++){
if (minv > d[i] && color[i] != 2){
u = i;
minv = d[i];
}
}
if ( u == -1) break;
color[u] = 2;
for (int v = 0;v < n;v++){
if (color[v] != 2 && a[u][v] != INF){
if (d[v] > a[u][v]){
d[v] = a[u][v];
p[v] = u;
color[v] = 1;
}
}
}
}
int sum = 0;
for (int i = 0;i < n;i ++){
if (p[i] != -1){
sum = sum + a[i][p[i]];
}
}
return sum;
}
int main()
{
cin >> n;
int x;
for (int i = 0;i < n;i++){
for (int j = 0;j < n;j++){
cin >> x;
if (x == -1){
a[i][j] = INF;
}
else{
a[i][j] = x;
}
}
}
cout << prim() << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define Rep(i,n) for(int i = 1; i <= n; i++)
#define sz(x) int(x.size())
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define YesorNo(a) printf(a ? "Yes\n" : "No\n")
#define endl '\n'
#define fi first
#define se second
using ll = long long;
using P = pair<int,int>;
using Pl = pair<ll,ll>;
template<class T> using V = vector<T>;
const int dx[] = {0,1,0,-1,1,1,-1,-1};
const int dy[] = {1,0,-1,0,1,-1,-1,1};
const int inf = (1<<30)-1;
const ll infll = (1LL<<62)-1;
ll ceil(const ll &a, const ll &b){return ((a)+(b)-1)/b;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
int main(){
int n;
cin >> n;
V<P> p(n);
rep(i,n) cin >> p[i].fi >> p[i].se;
double ans = 0;
rep(i,n)rep(j,n) {
if(i == j) continue;
ans += sqrt((p[i].fi-p[j].fi)*(p[i].fi-p[j].fi) + (p[i].se-p[j].se)*(p[i].se-p[j].se)) * (n-1);
}
ans /= n*(n-1);
printf("%.10f", ans);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
long double dx,dy,RR,avdist,prt;
cin >>N;
int arrive[N];
vector<vector<long double>> b(N, vector<long double>(2));
vector<vector<long double>> dist(N, vector<long double>(N,0));
for(int i=0;i<N;i++){
arrive[i]=i;
cin >> b.at(i).at(0) >> b.at(i).at(1);
}
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
dx=b.at(i).at(0)-b.at(j).at(0);
dy=b.at(i).at(1)-b.at(j).at(1);
RR=pow(pow(dx,2)+pow(dy,2),0.5);
dist.at(i).at(j)= RR;
//cout << RR << endl;
}
}
avdist=0;
prt=0;
do{
for(int k=0;k<N-1;k++){
avdist+=dist.at(arrive[k]).at(arrive[k+1]);
}
prt+=1;
}while(next_permutation(arrive, arrive + N));
cout << fixed << setprecision(10) << avdist/prt << endl;
return 0;
} | 1 |
#include <iostream>
#include <unordered_map>
#include <cmath>
void FactrizePrime(int x, std::unordered_map<int, int> &count)
{
while (x % 2 == 0)
{
++count[2];
x /= 2;
}
for (int i = 3; i <= x; i += 2)
{
while (x % i == 0)
{
++count[i];
x /= i;
}
}
}
constexpr int32_t MOD = 1000000007;
int main()
{
int n;
std::cin >> n;
if (n == 1 || n == 2)
{
std::cout << n << std::endl;
return 0;
}
std::unordered_map<int, int> factor;
for (int i = 2; i <= n; ++i)
{
FactrizePrime(i, factor);
}
int64_t count = 1;
for (const auto &p : factor)
{
count *= p.second + 1;
count %= MOD;
}
std::cout << count << std::endl;
return 0;
}
| #include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define what_is(x) cerr << #x << " is " << x << endl;
#define MT make_tuple
#define eb emplace_back
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define FOR(i,n) for (int i=0;i < n ; i++)
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
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...);
}
ll mod=1e9+7;
bool* sieve(ll n){
bool* a=new bool[n+1];
for(ll i=0;i <n+1;i++) a[i]=true;
for(ll i=2;i<n/2;i++){
if(a[i]==false) continue;
ll k=2;
while(i*k <=n){
a[i*k]=false;
k++;
}
}
return a;
}
int main(){
ll n;
cin >> n;
bool* b=sieve(n);
ll ans=1;
for(ll i=2; i <n+1;i++){
if(b[i]){
ll j=i;
ll count=0;
while(j<=n){
count+=n/j;
j*=i;
}
ans*=count+1;
ans%=mod;
}
}
cout << ans;
return 0;
} | 1 |
#include <iostream>
using namespace std;
long long cnt = 0; //for counting num of invensions
void merge(int *a, int left, int mid, int right) {
int nL = mid - left;
int nR = right - mid;
int L[nL], R[nR];
for(int i=0; i<nL; i++) {
L[i] = a[left + i];
}
for(int i=0; i<nR; i++) {
R[i] = a[mid + i];
}
int indexL = 0, indexR = 0;
int k = left;
while(k<right) {
if( indexL>=nL ) { //in case that L[] has no element
a[k] = R[indexR]; //this is not inversion
indexR++;
} else if( indexR>=nR ) { //in case that R[] has no element
a[k] = L[indexL]; //this is not inversion
indexL++;
} else if( L[indexL] <= R[indexR] ) {
a[k] = L[indexL]; //this is not inversion
indexL++;
} else if( L[indexL] > R[indexR] ) { //actually, this condition is not needed
a[k] = R[indexR]; //this is inversion
indexR++;
cnt += nL - indexL; //num of inversion = num of elements remaining in L[]
}
k++;
}
// //display info. about this step
// cout << "-----\n";
// cout << "merge(" << left << ", " << mid << ", " << right <<")" << endl;
//
// cout << "L" << " = "; for(int i=0; i<nL; i++) {cout << L[i] << " ";} cout << endl;
// cout << "R" << " = "; for(int i=0; i<nR; i++) {cout << R[i] << " ";} cout << endl;
//
// cout << "cnt = " << cnt << endl;
return;
}
void mergeSort(int *a, int left, int right) {
if(left+1 < right) {
int mid = (left + right) / 2;
mergeSort(a, left, mid);
mergeSort(a, mid, right);
merge(a, left, mid, right);
}
return;
}
int main(void) {
int N;
cin >> N;
int a[N];
for(int i=0; i<N; i++) {
cin >> a[i];
}
// //display a[] before sorting
// cout << "a[] = ";
// for(int i=0; i<N; i++) {
// cout << a[i] << " ";
// }
// cout << endl;
//merge sort a[]
mergeSort(a, 0, N);
// //display a[] after sorting
// cout << "a[] = ";
// for(int i=0; i<N; i++) {
// cout << a[i] << " ";
// }
// cout << endl;
// cout << "Num of inversions = ";
cout << cnt << endl;
return 0;
} | #include <cstdio>
#include <vector>
#include <algorithm>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int n;
int a[200000];
int b[200001];
void add(int i, int x){
while(i <= n){
b[i] += x;
i += i & -i;
}
}
int sum(int i){
int s = 0;
while(i > 0){
s += b[i];
i -= i & -i;
}
return s;
}
int main(){
scanf("%d", &n);
rep(i, n){
scanf("%d", &a[i]);
}
vector<P> v;
rep(i, n){
v.push_back(P(a[i], i));
}
sort(v.begin(), v.end());
a[v[0].second] = 0;
rep(i, n - 1){
a[v[i + 1].second] = a[v[i].second] + (v[i].first != v[i + 1].first);
}
ll ans = 0;
for(int i = n - 1; i >= 0; --i){
ans += sum(a[i]);
add(a[i] + 1, 1);
}
printf("%lld\n", ans);
return 0;
} | 1 |
#include<bits/stdc++.h>
#define rint register int
#define rep(i,a,b) for (rint i=(a),_E=(b); i<=_E; ++i)
#define per(i,a,b) for (rint i=(a),_E=(b); i>=_E; --i)
#define REP(i,n) for (rint i=(0),_E=(n); i<_E; ++i)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
const int N = 100005;
priority_queue<int> Q;
int n, res;
pii a[N];
ll now;
int main() {
scanf("%d", &n);
rep (i, 1, n) {
scanf("%d%d", &a[i].fi, &a[i].se);
a[i].fi += a[i].se;
}
sort(a + 1, a + n + 1);
rep (i, 1, n) {
now += a[i].se;
Q.push(a[i].se);
if (now > a[i].fi) {
now -= Q.top();
Q.pop();
}
}
cout << Q.size() << endl;
return 0;
} | #include <bits/stdc++.h>//Carefully Crafted by hetp111
using namespace std;
#define int long long
#define double long double
#define all(v) (v).begin(),(v).end()
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int,int>
#define vii vector<pii>
#define MOD (1000000007)
//#define MOD (998244353)
#define PI acos(-1)
#define eps (1e-8)
#define INF (1e18)
#define FASTER ios_base::sync_with_stdio(0);cin.tie(0)
template<class A,class B>ostream&operator<<(ostream&out,const pair<A,B>&a){return out<<"("<<a.first<<","<<a.second<<")";}
template<class A>ostream&operator<<(ostream&out,const vector<A>&a){for(const A &it:a)out<<it<<" ";return out;}
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}
//ifstream cinn("input.txt");ofstream coutt("output.txt");
vii v;
int n,dp[5000][5001];
int f(int i,int k){// f(i,j) min price when j items taken and i items included
if(k<0)return INF;
if(i==-1){
if(k>0)return INF;
return 0;
}
int &ans=dp[i][k];
if(ans!=-1)return ans;
ans=INF;
int picheka=f(i-1,k-1);
if(picheka<=v[i].first)ans=min(ans,picheka+v[i].second);
ans=min(ans,f(i-1,k));
return ans;
}
signed main(){
FASTER;
memset(dp,-1,sizeof dp);
cin>>n;
v=vii(n);cin>>v;
sort(all(v),[](const pii &a,const pii &b){return a.first+a.second<b.first+b.second;});
for(int i=n;i>=0;i--){
if(f(n-1,i)!=INF){
cout<<i;
return 0;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e16
typedef long long ll;
int main() {
ll N;
cin >> N;
ll m = INF;
REP(i,5){
ll t;
cin >> t;
m = min(m,t);
}
cout << 5 + (N-1)/m << endl;
return 0;
} | #include<iostream>
#include<vector>
using namespace std;
void print(vector<int> &v){
vector<int>::iterator ite = v.begin();
while(ite != v.end()){
cout << *ite << endl;
ite++;
}
}
int insSort(vector<int> &v, int g){
int i, j, x, n = v.size(), cnt = 0;
for(i = g; i < n; i++){
x = v[i];
j = i - g;
while(j >= 0 && v[j] > x){
v[j+g] = v[j];
cnt++;
j -= g;
}
v[j+g] = x;
}
return cnt;
}
void makeG(vector<int> &v,int n){
for(int i = 1; ;){
if(i > n) break;
v.push_back(i);
i = 3*i + 1;
}
}
void shellSort(vector<int> &v){
int i, cnt = 0;
vector<int> g;
makeG(g, v.size());
int gs = g.size();
cout << gs << endl;
for(i = gs - 1; i >= 0; i--){
if(i != gs - 1)
cout << " ";
cout << g[i];
cnt += insSort(v, g[i]);
}
cout << endl << cnt << endl;
}
int main(){
int n, x, i;
vector<int> v;
cin >> n;
for(i = 0; i < n; i++){
cin >> x;
v.push_back(x);
}
shellSort(v);
print(v);
return 0;
} | 0 |
#include <iostream>
#include <string>
using namespace std;
static const int MAX_LENGTH = 1000;
void nreplace(char *input, int start, int end, char *target);
void nswap(char *input, int start, int end);
void nprint(char *input, int start, int end);
int main(void) {
char *input = new char[MAX_LENGTH+1];
char *target = new char[MAX_LENGTH+1];
string command;
int N, s, e;
cin >> input;
cin >> N;
while(N-- > 0) {
cin >> command >> s >> e;
if(command == "replace") {
cin >> target;
nreplace(input, s, e, target);
}
if(command == "reverse") nswap(input, s, e);
if(command == "print") nprint(input, s, e);
}
return 0;
}
void nreplace(char *input, int start, int end, char *target) {
for(int i=start; i<=end; i++)
input[i] = target[i-start];
}
void nswap(char *input, int start, int end) {
char *st = input;
char *ed = input;
char tmp;
for(int i=0; i<start; i++) st++;
for(int i=0; i<end; i++) ed++;
while(st < ed) {
tmp = *st;
*st++ = *ed;
*ed-- = tmp;
}
}
void nprint(char *input, int start, int end) {
for(int i=start; i<=end; i++) cout << input[i];
cout << endl;
} | #include<stdio.h>
int main()
{
int masu[12][12];
int n,i,j,w=0,h=0,t=0;
for(;;h=0,w=0,t=0){
for(i=0;i<11;i++){
for(j=0;j<11;j++){
masu[i][j]=0;
}
}
scanf("%d",&n);
if(n==0)break;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
scanf("%d",&masu[i][j]);
}
}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
w+=masu[i][j];
h+=masu[j][i];
}
masu[i][j]=w;
masu[j][i]=h;
w=0;
h=0;
}
for(i=0;i<=n;i++){
t+=masu[n][i];
}
masu[i-1][j]=t;
for(i=0;i<=n;i++){
for(j=0;j<=n;j++){
printf("%5d",masu[i][j]);
}
puts("");
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,k,n) for(int i=k;i<n;++i)
#define repe(i,k,n) for(int i=k;i<=n;++i)
using namespace std;
int main()
{
cin.tie(0);cout.tie(0);
ios::sync_with_stdio(false);
int a,b;
cin >> a >> b;
int in = 1,res=0;
while (in <b){
in += a - 1;
res += 1;
}
cout << res ;
return 0;
}
| #include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <string>
#include <numeric>
#include <cmath>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
template<class T> inline bool chmin(T& a,T b) {if (a > b) {a = b; return true;} return false;}
template<class T> inline bool chmax(T& a,T b) {if (a < b) {a = b; return true;} return false;}
const ll MOD = 1000000007;
const int INF = 1<<30;
//const ll INF = (ll)1e18 + 1;
ll choose(ll n){
return n * (n - 1) / 2;
}
int main(){
ll N, M; cin >> N >> M;
vector<ll> a(N); rep(i, N) cin >> a[i];
vector<ll> s(N + 1, 0);
rep(i, N) s[i + 1] = s[i] + a[i];
map<ll, ll> mp;
for (int i = 1; i < N + 1; ++i) mp[s[i] % M]++;
ll ans = 0;
for (auto v: mp){
ans += choose(v.second);
}
ans += mp[0];
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int N,K;
cin >> N >> K;
if(N%K) cout << "1\n";
else cout << "0\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
cin>>N>>K;
cout<<((N%K)+K-1)/K<<endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll n;
cin >> n;
vector<int> a(n, 0);
vector<ll> ans(n, 0);
ll fee = 0;
for (ll i = 0; i < n; i++)
{
cin >> a[i];
}
ll tmp = 0;
for (ll i = 0; i < n + 1; i++)
{
if (i == n)
{
fee += abs(tmp - 0);
break;
}
fee += abs(tmp - a[i]);
tmp = a[i];
}
for (ll i = 0; i < n; i++)
{
ans[i] = fee - (abs(a[i] - a[i - 1]) + abs(a[i + 1] - a[i])) + (abs(a[i + 1] - a[i - 1]));
}
for (ll i = 0; i < n; i++)
{
cout << ans[i] << endl;
}
}
| #include <iostream>
#include <stack>
#include <algorithm>
#include <cstdio>
#include <sstream>
#include <vector>
#include <string>
#include <cmath>
#define rep(x,to) for(int x=0;x<to;x++)
#define rep2(x,from,to) for(int x=from;x<to;x++)
using namespace std;
int main(void){
string ws;
int n;
while(cin >> n){
if(n==0 || cin.eof()) break;
vector<vector<int> > hg(n+1,vector<int>(n+1,0));
rep(i,n) rep(j,n) cin >> hg[i][j];
rep(i,n) rep(j,n){
hg[n][i] += hg[j][i];
hg[i][n] += hg[i][j];
}
rep(i,n) hg[n][n] += hg[i][n];
rep(i,n+1){
rep(j,n+1) printf("%5d",hg[i][j]);
printf("\n");
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using ll = long long;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;
const ll INF = (ll)1e11;
const ll MOD = 998244353;
using namespace std;
int main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A;
ll S = 0;
for (int i = 0, a; i < N; ++i) {
cin >> a;
A.push_back(a);
S += a;
}
ll cnt = 1;
for (int i = 0; i < N; ++i) {
cnt *= 3; // all ways to paint stones
cnt %= MOD;
}
// subtract the numbers of ways to paint such that R,G,B cannot construct a triangle from all.
{ // reduce the number of ways to paint such that R >= G + B, G >= B + R, B >= R + G
vector<ll> dp(S + 10, 0);
dp[0] = 1; // assume that R = max(R,G,B) here
for (auto a : A) {
for (ll s = S; s > a - 1; --s) {
dp[s] += 2 * dp[s-a]; // select a_i in G or B
dp[s] %= MOD;
}
}
for (ll s = 0; s < S / 2 + 1; ++s) {
cerr << "----" << endl;
cnt -= 3 * dp[s]; // subtract sum of R, G, B = max(R,G,B)
while (cnt < 0) cnt += 3 * MOD;
cnt %= MOD;
cerr << cnt << endl;
}
}
cerr << cnt << endl;
if (S % 2 == 0) { // add the number of ways to paint such that R == G && B == 0, G == B && R == 0, B == R && G == 0
vector<ll> dp(S + 10, 0);
dp[0] = 1; // assume that R == G && B == 0 here
for (auto&& a : A) {
for (ll s = S; s > a - 1; --s) {
dp[s] = (dp[s] + dp[s-a]) % MOD; // select a_i in R (G)
dp[s] %= MOD;
}
}
cnt += 3ll * dp[S/2]; // add sum of R,G,B == 0
cnt %= MOD;
}
cout << cnt << endl;
return 0;
}
| //#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 inf = 1e9 + 7;
const int N = 6e3 + 5;
const double eps = 1e-9;
int n, mod;
int add(int x, int y) { return x+y < mod ? x+y : x+y-mod; }
int mul(int x, int y) { return x*1ll*y % mod; }
int dp[N][2*N], fac[N];
int main() {
scanf("%d %d", &n, &mod);
dp[0][3*n] = 1;
for (int i = 1; i <= 3*n; i++) {
for (int j = 0; j <= 6*n; j++) {
if (j > 0)
dp[i][j] = add(dp[i-1][j-1], dp[i][j]);
if (i > 1)
dp[i][j] = add(dp[i][j], mul(dp[i-2][j+1], i-1));
if (i > 2)
dp[i][j] = add(dp[i][j], mul(dp[i-3][j], mul(i-1,i-2)));
}
}
int ans = 0;
for (int i = 3*n; i <= 6*n; i++)
ans = add(ans, dp[3*n][i]);
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI pair<int,int>
const int maxm=1e6+5;
int a[maxm];
int n;
signed main(){
cin>>n;
for(int i=1;i<=n*2;i++)cin>>a[i];
int ans=0;
sort(a+1,a+1+n*2);
for(int i=1;i<=n*2;i+=2){
ans+=min(a[i],a[i+1]);
}
cout<<ans<<endl;
return 0;
}
/*
*/
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll,int> plli;
typedef pair<double, int> pdbi;
typedef pair<int,pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1<<30;
const ll mod = 1000000000 + 7;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
//#define int long long
#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int costa[1005] = {};
fill(costa, costa + 1005, INF);
rep(i, n) {
int c;
cin >> c;
bool check = false;
int mn = i + 1;
rep2(j, 1, c + 1) {
mn = min(mn, costa[j]);
}
costa[c] = mn;
}
int cnt[1005] = {};
rep(i, m) {
int c;
cin >> c;
int mn = INF;
rep(j, c + 1) {
mn = min(mn, costa[j]);
}
cnt[mn]++;
}
int mx = -1;
int ans = 0;
rep(i, 1005) {
if (cnt[i] > mx) {
mx = cnt[i];
ans = i;
}
}
cout << ans << endl;
} | 0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int n,m;
int s[5];
int c[5];
int main()
{
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
scanf("%d %d",&s[i],&c[i]);
for(int i=0;i<1000;i++)
{
char num[5];
sprintf(num,"%d",i);
// itoa(i,num,10);
if(strlen(num)!=n) continue;
bool flag=true;
for(int j=0;j<m;j++)
{
if(num[s[j]-1]!=c[j]+'0')
{
flag=false;
break;
}
}
if(flag)
{
printf("%d\n",i);
return 0;
}
}
printf("-1\n");
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>;
int main() {
int N, M;
cin >> N >> M;
vector<int> ds(N, -1);
bool isExist = true;
rep(i, M) {
int s, c;
cin >> s >> c;
s--;
if (ds[s] == -1) {
ds[s] = c;
} else if (ds[s] != c) {
isExist = false;
}
}
if (!isExist) {
cout << -1 << endl;
return 0;
}
if (2 <= N) {
int sum = 0;
if (ds[0] == 0) {
cout << -1 << endl;
return 0;
} else if (ds[0] == -1) {
sum = 1;
} else {
sum = ds[0];
}
for (int i = 1; i < N; i++) {
if (ds[i] == -1) {
sum = sum * 10;
} else {
sum = sum * 10 + ds[i];
}
}
cout << sum << endl;
return 0;
} else {
if (ds[0] == -1) {
cout << 0 << endl;
} else {
cout << ds[0] << endl;
}
}
return 0;
} | 1 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define pp pair<pair<ll, ll>,pair<ll, ll>>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define vii vector<int>
#define vll vector<ll>
#define mat vector<vector<ll>>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep2(i,a,b) for(ll i=a;i<b;i++)
#define repr(i,n) for(ll i=n-1;i>=0;i--)
#define all(x) x.begin(),x.end()
#define pq priority_queue<ll>
#define pqg priority_queue<ll,vector<ll>,greater<ll>>
#define LB(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define UB(v,x) (upper_bound(v.begin(),v.end(),x)-v.begin())
#define ERASE(v) sort(v.begin(),v.end());v.erase(unique(v.begin(),v.end()),v.end())
// #define int ll
using namespace std;
const ll INF = (1 << 30 ) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] ={1,0,-1,0} , dy[4] ={0,1,0,-1};
struct Timer{
chrono::system_clock::time_point start, end;
Timer(){ start = chrono::system_clock::now(); }
~Timer(){
end = chrono::system_clock::now();
auto msec = chrono::duration_cast<chrono::milliseconds>(end - start).count();
cerr<<"time : "<<msec<<" ms"<<endl;
}
};
ll n;
ll a[200010]={};
ll cnt[200010]={};
vll G[200010];
ll ans[200010]={};
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Timer TM;
ll n;
ll ans=0;
string s;
unordered_map<string,ll> mp;
cin>>n>>s;
rep(bit,(1<<n)){
string u="",t="";
rep(i,n){
if(bit&(1<<i)){
u+=s[i];
}
else t+=s[i];
}
mp[u+'0'+t]++;
// cout<<u+'0'+t<<endl;
}
rep(bit,(1<<n)){
string u="",t="";
rep(i,n){
if(bit&(1<<i)){
u=s[i+n]+u;
}
else t=s[i+n]+t;
}
if(mp[t+'0'+u]>0) ans+=mp[t+'0'+u];
}
cout<<ans<<endl;
return 0;
} | #include <cstring>
#include <cctype>
#include <cstdio>
inline int read(int f = 1, int x = 0, char ch = ' ')
{
while(!isdigit(ch = getchar())) if(ch == '-') f = -1;
while(isdigit(ch)) x = x*10+ch-'0', ch = getchar();
return f*x;
}
const int N = 1e2+5;
int max(int a, int b) { return a>b?a:b; }
int min(int a, int b) { return a<b?a:b; }
short f[N][N][N][N], g[N][N], h[N][N];
char s[N][N];
int n, m, ans, px, py;
int main()
{
n = read(), m = read(); memset(f, -1, sizeof(f));
for(int i = 1; i <= n; ++i) scanf("%s", s[i]+1);
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= m; ++j)
{
if(s[i][j] == 'E') px = i, py = j;
g[i][j] = g[i][j-1]+(s[i][j] == 'o');
h[i][j] = h[i-1][j]+(s[i][j] == 'o');
}
f[0][0][0][0] = 0;
int pl = py-1, pr = m-py, pd = px-1, pu = n-px, p;
for(int l = 0; l <= pl; ++l)
for(int r = 0; r <= pr; ++r)
for(int d = 0; d <= pd; ++d)
for(int u = 0; u <= pu; ++u)
{
if(!(~f[l][r][d][u])) continue;
int cl = max(r+1, py-l), cr = min(m-l, py+r);
int cd = max(u+1, px-d), cu = min(n-d, px+u);
if((p = py+r+1) <= m-l) f[l][r+1][d][u] = max(f[l][r+1][d][u], f[l][r][d][u]+h[cu][p]-h[cd-1][p]);
if((p = py-l-1) >= r+1) f[l+1][r][d][u] = max(f[l+1][r][d][u], f[l][r][d][u]+h[cu][p]-h[cd-1][p]);
if((p = px+u+1) <= n-d) f[l][r][d][u+1] = max(f[l][r][d][u+1], f[l][r][d][u]+g[p][cr]-g[p][cl-1]);
if((p = px-d-1) >= u+1) f[l][r][d+1][u] = max(f[l][r][d+1][u], f[l][r][d][u]+g[p][cr]-g[p][cl-1]);
ans = max(ans, f[l][r][d][u]);
}
printf("%d\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long k;
int main(){
cin>>s;
for(int i=0;i<s.size();i++){
if(s[i]=='7')k++;
}
if(k>0)cout<<"Yes";
else cout<<"No";
return 0;}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
string s;
cin >> s;
if(s.at(0)=='7' ||s.at(1)=='7' || s.at(2)=='7') cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 1 |
#pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <bitset>
using namespace std;
typedef long long ll;
//#define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma region UnionFind
struct UnionFind
{
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x)
{
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y)
{
return root(x) == root(y);
}
bool merge(int x, int y)
{
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x)
{
return -par[root(x)];
}
};
#pragma endregion
#pragma region GCD
int gcd(int a, int b)
{
if (a%b == 0)return b;
return gcd(b, a%b);
}
#pragma endregion
#pragma region chmin
template<class T> inline bool chmin(T& a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma region chmax
template<class T> inline bool chmax(T& a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma endregion
int main()
{
int a, b; cin >> a >> b;
vector<string> res;
rep(i, 50)
{
string s = "";
rep(j, 100)s += '.';
res.push_back(s);
}
rep(i, 50)
{
string s = "";
rep(j, 100)s += '#';
res.push_back(s);
}
int x = 0;
int y = 0;
--a, --b;
while (b > 0)
{
if (y >= 100)
{
x += 2;
y = 0;
}
res[x][y] = '#';
y += 2;
--b;
}
x = 51;
y = 0;
while (a > 0)
{
if (y >= 100)
{
x += 2;
y = 0;
}
res[x][y] = '.';
y += 2;
--a;
}
cout << 100 << " " << 100 << endl;
rep(i, 100)cout << res[i] << endl;
} | #include<iostream>
using namespace std;
int main(){
int A,B,h=100,w=100;
char g[100][100];
for(int i=0;i<h*w;i++)g[i/w][i%w]=(i<h*w/2?'#':'.');
cin>>A>>B;
cout<<"100 100"<<endl;
for(int i=0;i<A-1;i++)g[2*(i/50)+1][2*(i%50)]='.';
for(int i=0;i<B-1;i++)g[98-2*(i/50)][2*(i%50)]='#';
for(int i=0;i<h*w;i++)cout<<g[i/w][i%w]<<(i%w+1==w?"\n":"");
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0;i<int(N);++i)
#define rep1(i,N) for(int i=1;i<int(N);++i)
#define all(a) (a).begin(),(a).end()
#define print(v) { cerr<<#v<<": [ "; for(auto _ : v) cerr<<_<<", "; cerr<<"]"<<endl; }
#define printpair(v) { cerr<<#v<<": [ "; for(auto _ : v) cerr<<"{"<<_.first<<","<<_.second<<"}"<<", "; cerr<<"]"<<endl; }
#define dump(x) cerr<<#x<<": "<<x<<endl;
#define bit(k) (1LL<<(k))
typedef long long ll;
typedef pair<int, int> i_i;
typedef pair<ll, ll> l_l;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
template< typename T1, typename T2 >
ostream &operator<<(ostream &os, const pair< T1, T2 >& p) {
os << "{" <<p.first << ", " << p.second << "}";
return os;
}
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 = (ll)1e9;
const ll INFLL = (ll)1e18+1;
const ll MOD = (ll)1e9+7;
const double PI = acos(-1.0);
/*
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string dir = "DRUL";
*/
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N;
cin >> N;
string s, t;
cin >> s >> t;
string ans = s + t;
for(int i = 1; i <= N; i++){
if(s.substr(N-i,i) == t.substr(0,i)){
ans = s + t.substr(i, N-i);
}
}
cout << ans.size() << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
string s,t;
cin>>N>>s>>t;
long long len1,len2,count=0;
len1=s.length();
len2=t.length();
if(len1==len2&&len1==N&&N>=1&&N<=100){
if (N>=len1+len2){
count=N;
}
else {
count=len1+len2;
for(int i=0;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(s.substr(i,len1)==t.substr(0,j)&&len1+len2-j>=N){
count=min(len1+len2-j,count);
}
}
}
}
cout<<count;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
long long int cnt=0;
void Merge(int A[],int left,int mid,int right)
{
int n1=mid-left;
int n2=right-mid;
int L[n1+1],R[n2+1];
int i,j;
for(i=0;i<n1;++i)
{
L[i]=A[left+i];
}
for(i=0;i<n2;++i)
{
R[i]=A[mid+i];
}
L[n1] = R[n2] = INT_MAX;
i=0;j=0;
for(int k=left;k<right;k++)
{
if(L[i]<=R[j])
{
A[k]=L[i++];
}
else
{
A[k]=R[j++];
cnt+=n1-i;
}
}
}
void mergesort(int A[],int left,int right)
{
int mid;
if(left+1<right)
{
mid=(left+right)/2;
mergesort(A,left,mid);
mergesort(A,mid,right);
Merge(A,left,mid,right);
}
}
int main(){
int A[500000],n,i;
scanf("%d",&n);
for(i=0;i<n;++i)
{
scanf("%d",&A[i]);
}
mergesort(A,0,n);
cout<<cnt<<endl;
return 0;
}
| #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#include <bits/stdc++.h>
using namespace std;
template<class t> inline t read(t &x){
char c=getchar();bool f=0;x=0;
while(!isdigit(c)) f|=c=='-',c=getchar();
while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
if(f) x=-x;return x;
}
template<class t,class ...A> inline void read(t &x,A &...a){
read(x);read(a...);
}
template<class t> inline void write(t x){
if(x<0) putchar('-'),write(-x);
else{if(x>9) write(x/10);putchar('0'+x%10);}
}
#define int long long
int n,tot,sum;
signed main(){
read(n);
for(int i=1,x,y;i<=n;i++){
read(x,y);
tot+=y;sum+=x*y;
}
write(tot-1+(sum-1)/9);
} | 0 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b;
cin >> a >> b;
cout << 2*b - a;
return 0;
} | #include <iostream>
#include <ios>
#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <utility>
#include <typeinfo>
#include <tuple>
using namespace std;
#define MOD 1000000007
#define INF 1e9+7
#define INF_LONG 1e18
#define rep(i, n) for(int i=0; i<n; ++i)
#define rep1(i, n) for(int i=1; i<=n; ++i)
#define rrep(i, m, n) for(int i=m; i<n; ++i)
#define countof(array) (sizeof(array) / sizeof(array[0]))
typedef long long ll;
#define MAX_N 100000
#define MAX_M 100000
#define MAX_V 100
#define MAX_E 100
#define MAX_Q 100000
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int ddx[] = {-1, 0, 1, 0, -1, 1, -1, 1};
int ddy[] = {0, -1, 0, 1, 1, 1, -1, -1};
string ab = {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
string as = {"abcdefghijklmnopqrstuvwxyz"};
ll gcd(ll x, ll y) {
if(y==0) return x;
else return gcd(y, x%y);
}
ll lcm(ll x, ll y) {
return (x*y)/gcd(x, y);
}
void yes() {
cout << "Yes" << endl;
}
void no() {
cout << "No" << endl;
}
void print_array(int array[], int len) {
for(int i=0; i<len; ++i) {
cout << array[i] << endl;
}
}
ll absolute(ll x) {
return (x<0)? (-1)*x : x;
}
//g++ AtCoder.cpp -o AtCoder
//AtCoder
//--------------------------
int main() {
int n;
cin >> n;
cout << 180*(n-2) << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep_inv(i, n, m) for(int i = (int)(n); i > (int)(m); i--)
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vc = vector<char>;
using vvl = vector<vl>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
int main(){
vl abc(3);
rep(i, 3) cin >> abc[i];
ll K;
cin >> K;
stable_sort(abc.begin(), abc.end());
rep(i, K) abc[2] *= 2;
cout << abc[0] + abc[1] + abc[2] << endl;
return 0;
}
| #include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <functional>
#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 = 10000000;
const int mod = 1e9 + 7;
const double EPS = 1e-9;
int n, k;
set<string> st;
string s;
vi v;
void calc(int c, vi u){
if(u.size() == k){
// rep(i, u.size()){
// cout<<" "<<u[i];
// }
// cout<<endl;
sort(all(u));
do{
string t;
for(int i = 0; i < k; i++){
t += to_string(u[i]);
}
st.insert(t);
}while(next_permutation(all(u)));
return;
}
for(int i = c; i<n; i++){
u.pb(v[i]);
calc(i+1, u);
u.pop_back();
}
}
int main(){
while(cin>>n>>k){
if(n == 0 && k == 0) break;
v = vi(n);
rep(i, n) cin>>v[i];
s = "";
st.clear();
vi tmp;
calc(0,tmp);
// for(auto it = st.begin(); it != st.end(); it++){
// cout<<" "<<*it<<endl;
// }
cout<<st.size()<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n)for(int i=0;i<(n);i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
int main(){
ll x; cin >> x;
ll ans = x/11;
int r = x % 11;
int add = 0;
if(r > 0) add = 1;
if(r > 6) add = 2;
cout << ans * 2 + add << endl;
} | #include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<string>
#include<unordered_map>
#include <iomanip>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j,k
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define sort(a) sort(a.begin(),a.end())
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define sizeoof(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
/*繰り上げ除算*/ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
/*最大公約数*/ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*最小公倍数*/ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
/*n乗*/ll llpow(ll x,ll n){ll i,ans=1;rep(i,0,n)ans*=x;return ans;}
/*階乗*/ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
/*nCr*/ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
/*nPr*/ll npr(ll n,ll r){return fact(n)/fact(n-r);}
/*primejudge*/bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
ll ans=0;llfor;///////////////////////////////////////////////////////////
int main(){
string S;
cin>>S;
int N=S.size();
int m=1000;
for(int i=0;i<=N-3;i++){
char a=S[i]-'0';
char b=S[i+1]-'0';
char c=S[i+2]-'0';
int K=100*a+10*b+c;
m=min(m,abs(K-753));
}
cout<<m;
return 0;}
| 0 |
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep2(i, l, r) for (int i = (l); i < (r); i++)
#define ALL(x) (x).begin(), (x).end() //昇順
#define RALL(x) (x).rbegin(), (x).rend() // 降順
#define pri(x) cout << (x) << "\n"
#define pri2(x, y) cout << (x) << " " << (y) << "\n"
#define pri3(x, y, z) cout << (x) << " " << (y) << " " << (z) << "\n"
const long long mod = 1e9 + 7;
typedef long long ll;
typedef priority_queue<int> PQ;
typedef vector<long long> VL;
typedef vector<bool> VB;
typedef vector<int> VI; // VI a(n);
typedef vector<double> VD;
typedef vector<string> VS;
typedef vector<char> VC;
typedef vector<VS> VSS;
typedef vector<VC> VCC;
typedef vector<VI> VII; // VII a(n,vector<int>(m)) n * m
typedef vector<VL> VLL;
typedef pair<int, int> PII;
typedef map<int, int> MP; // MP a;
typedef vector<pair<ll, ll>> PS;
template <class T, class U>
bool chmax(T &a, U b) {
if (a <= b) {
a = b;
return 1;
}
return 0;
}
template <class T, class U>
bool chmin(T &a, U b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
os << "{";
rep(i, (int)v.size()) { os << v[i] << (i < v.size() - 1 ? ", " : ""); }
os << "}";
return os;
}
// g++ -std=c++11 prac.cpp
// operator << (cout,a);
// chmin(min,a)
vector< ll > divisor(ll n) {
vector< ll > ret;
for(ll i = 1; i * i <= n; i++) {
if(n % i == 0) {
ret.push_back(i);
if(i * i != n) ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
ll fac(ll n){ // 階乗
ll sum = 1;
for(ll i=1; i <= n; i++){ sum *= i; }
return sum;
}
int main() {
ll n, m, k, x, y = 0, z = 0, h, ans=0, w, sum = 0, Max = -1, Min = 1e9+1;
string s, t, u;
bool ok=true;
cin >> n;
w = n%11;
ans = (n/11)*2;
if(w>=7) ans += 2;
else if(w>0) ans+=1;
pri(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
queue<int> s[5];
char winner;
for(int i=0;i<3;i++) {
string st;
cin>>st;
for(int j=0;j<(int)st.size();j++) s[i].push(st[j]-'a');
}
int now=0;
while(1) {
if(s[now].empty()) {winner=now+65;break;}
int t=s[now].front();
s[now].pop();
now=t;
}
cout<<winner<<endl;
return 0;
} | 0 |
/*
t.me/ivanesipovvpered
*/
#pragma ARCENIY_KIRILLOV_POVELITEL_KROKODILOV
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("no-stack-protector")
//#pragma GCC push_options
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC pop_options
#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define rng(a) a.begin(), a.end()
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define int long long
using namespace std;
typedef long long ll;
const double EPS = 1e-5;
const int mod = 1e9 + 7;
const ll INFLL = 1e18;
const int INF = 1e9;
const int maxn = 1e6 + 3;
ll gcd(ll a, ll b){
if (b == 0ll)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
return (a / gcd(a, b) )* b;
}
bool is_prime(ll a){
if (a == 2 || a == 3 || a == 5 || a == 7) return true;
if (a % 2 == 0 || a%3 == 0 || a%5 == 0 || a%7 == 0)
return false;
for (ll i = 11; i * i <= a; i += 2){
if (a % i == 0)
return false;
}
return true;
}
ll binpow(ll a, int n){
if (a == 0)
return 1;
if (a % 2 == 0){
ll q = binpow(a, n / 2);
return (q * q) ;
}else return (a * binpow(a, n - 1) ) ;
}
main(){
int n;
cin >> n;
vector<ll> primes;
ll a[n][n];
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
a[i][j] = 0;
}
}
int fe = 2;
while (primes.size() < n + n + 2){
if (is_prime(fe)) primes.pb(fe);
fe++;
}
int q = 0;
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
if ((i + j) % 2 == 0){
a[i][j] = primes[(i + j) / 2];
q = max(q, (i + j) / 2);
}
}
}
for (int j = n - 1; j > -1; j--){
for (int i = 0; i < n; i++){
if ((i + j) % 2 == 0){
a[i][j] *= primes[q + 1 + (i + (n - j)) / 2];
}
}
}
map<ll,bool> kek;
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
if (a[i][j]) continue;
int qe = 1, we = 1;
if (i)
qe = a[i-1][j];
if (i < n - 1)
qe = lcm(qe, a[i+1][j]);
if (j)
we = a[i][j-1];
if (j < n-1)
we = lcm(we,a[i][j+1]);
int ce = lcm(qe, we);
int flex = ce;
while (kek[ce]){
ce += flex;
}
kek[ce] = 1;
a[i][j] = ce + 1;
}
}
for (int i = 0; i < n; i++){
for (int j = 0 ; j< n; j++){
cout << a[i][j] << ' ';
}
cout << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
const int N=505;
const int M=4*N;
const int S=10000;
int pr[M],psz;
bool sieve[S];
ll val[N][N];
vector<pair<int,int> > id;
int Find(pair<int,int> x){ return lower_bound(id.begin(),id.end(),x)-id.begin()+1;}
int main()
{
int i,j;
for(i=2;i<S;i++) if(!sieve[i]){ pr[++psz]=i;for(j=i;j<S;j+=i) sieve[j]=1;}
int n;
scanf("%i",&n);
if(n==2) return 0*printf("4 7\n23 10\n");
for(i=1;i<=n;i++) for(j=1;j<=n;j++) if((i+j)&1)
{
int a=i+j,b=i-j;
id.pb(mp(1,a));
id.pb(mp(2,b));
}
sort(id.begin(),id.end());
id.erase(unique(id.begin(),id.end()),id.end());
for(i=1;i<=n;i++) for(j=1;j<=n;j++) if((i+j)&1)
{
int a=Find(mp(1,i+j));
int b=Find(mp(2,i-j));
val[i][j]=(ll)pr[a]*pr[b];
}
for(i=1;i<=n;i++) for(j=1;j<=n;j++) if(!((i+j)&1))
{
val[i][j]=1;
if(i-1>0 || j+1<=n) val[i][j]*=pr[Find(mp(2,i-j-1))];
if(i+1<=n || j-1>0) val[i][j]*=pr[Find(mp(2,i-j+1))];
if(i-1>0 || j-1>0) val[i][j]*=pr[Find(mp(1,i+j-1))];
if(i+1<=n || j+1<=n) val[i][j]*=pr[Find(mp(1,i+j+1))];
val[i][j]++;
}
for(i=1;i<=n;i++) for(j=1;j<=n;j++) printf("%lld%c",val[i][j],j==n?'\n':' ');
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
string s;
cin >> s;
int64_t n = s.size();
int64_t ans = 1;
vector<int64_t> nums('z' - 'a' + 1);
for (auto i : irange(0L, n)) {
int64_t c = s[i] - 'a';
ans += i - nums[c];
++nums[c];
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;
//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
//逆元(Eucledean algorithm)
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
void solve() {
string s; cin >> s;
ll n = s.size();
unordered_map<char, ll> m;
rep(i, n){
m[s[i]]++;
}
ll res = 0;
for(auto p: m){
res += p.second*(p.second-1)/2;
}
cout << n*(n-1)/2 + 1 - res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(10);
//init_f();
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, to) for (int i = 0; i < (to); ++i)
#define repf(i, from, to) for (int i = (from); i < (to); ++i)
#define unless(cond) if (!(cond))
using namespace std;
using ll = long long;
template <typename T>
using V = vector<T>;
template <typename T, typename U>
using P = pair<T, U>;
int main() {
string s;
cin >> s;
s[3] = '8';
cout << s << endl;
}
| #include <bits/stdc++.h>
#define range(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, a) range(i, 0, a)
using namespace std;
int main() {
string s;
cin >> s;
vector <pair <char, int>> ci;
rep (i, s.size()) {
if ((i == 0) || (i != 0 && s[i] != s[i - 1])) ci.emplace_back(s[i], 1);
else ci.back().second ++;
}
int ans = 0;
rep (i, (int)ci.size() - 2) {
if (ci[i].first == 'J' && ci[i + 1].first == 'O' && ci[i + 2].first == 'I') {
if (ci[i].second >= ci[i + 1].second && ci[i + 1].second <= ci[i + 2].second) {
ans = max(ans, min({ci[i].second, ci[i + 1].second, ci[i + 2].second}));
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
void solve(long long N){
cout << N / 3 << '\n';
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
long long N;
scanf("%lld",&N);
solve(N);
return 0;
}
| #include<bits/stdc++.h>
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long int
using namespace std;
int mod = 1e9 + 7;
int32_t main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fastio;
string s;
cin >> s;
int count = 0, max_count = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'R')
count++;
else {
count = 0;
}
max_count = max(count, max_count);
}
cout << max_count;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#define fo(i, n) for(int i=0; i<n; i++)
#define Fo(i, k, n) for(int i=k; i<n; i++)
#define w(x) int x; cin>>x; while(x--)
#define watch(x) cout << (#x) << " is " << (x) << "\n"
#define watch2(x,y) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<"\n"
#define watch3(x,y,z) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<"\n"
#define watch4(x,y,z,q) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<" and "<<(#q)<<" is "<<(q)<<"\n"
#define MOD 1000000007
#define INF 1000000007;
#define F first
#define S second
#define pb(x) push_back(x);
#define ll long long
#define all(c) (c).begin(),(c).end()
#define endl "\n"
typedef vector<int> vl;
typedef vector< vl > vvl;
typedef pair< int, int> pll;
typedef map< int, int> mll;
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
void c_p_c()
{
#ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void parray(int a[],int n){
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
}
int main() {
int i,n,m,k,c=0,sum=0;
c_p_c();
// cout<<c<<endl;
string s;
cin>>s;
n = (int)s.size();
int ans =753;
int mini=INF;
for (int i = 0,j=2; i <=n-3; i++)
{
/* code */
// j++;
string str=s.substr(i,3);
// watch(str-"0");
int x = stoi(str);
// debug(x);
mini=min(mini,abs(ans-x));
}
cout<<mini<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll S;
ll N = 1;
cin >> S;
while (S/(ll)pow(10,N)) {
//cout << pow(10,N) << endl;
//cout << S/pow(10,N) << endl;
//cout << N << endl;
N++;
}
//cout << N << endl;
ll ans = 1000;
for(int i = 0; i < N-2; i++) {
ans = min(ans,abs(753 - (S/(int)pow(10,i))%1000));
}
cout << ans << endl;
return 0;
} | 1 |
#include<stdio.h>
int main()
{
int N, count=0, min, i=0;
scanf("%d", &N);
int P[N+5];
while(i != N)
{
scanf("%d", &P[i]);
i++;
}
if(P[0] <= N)
{
count++;
//printf("1st count = %d\n", count);
min = P[0];
}
for(i=1; i<N; i++)
{
if(P[i] < min)
{
min = P[i];
count++;
//printf("count = %d\nmin = %d=%d\n", count, i, min);
}
}
printf("%d\n", count);
return 0;
}
| #include <vector>
#include <iostream>
#include <iomanip>
using namespace std;
typedef long int ll;
double solve(vector<vector<vector<double>>>& dp,vector<vector<vector<bool>>>& memo,int a,int b,int c,int n)
{
if (a<0 || b<0 || c<0) return 0;
if (a==0 && b==0 && c==0) return 0;
if (memo[a][b][c]) return dp[a][b][c];
double den = double(a) + double(b) + double(c);
double A = (double(a)/den) * solve(dp,memo,a-1,b,c,n);
double B = (double(b)/den) * solve(dp,memo,a+1,b-1,c,n);
double C = (double(c)/den) * solve(dp,memo,a,b+1,c-1,n);
memo[a][b][c] = true;
double ex = double(n)/den;
dp[a][b][c] = A + B + C + ex;
//cout<<dp[a][b][c]<<endl;
return dp[a][b][c];
}
int main()
{
int N;
cin>>N;
int a = 0;
int b = 0;
int c = 0;
for (int i=0;i<N;++i)
{
int x;
cin>>x;
if (x==1) ++a;
if (x==2) ++b;
if (x==3) ++c;
}
vector<vector<vector<double>>> dp(N+1,vector<vector<double>>(N+1,vector<double>(N+1)));
vector<vector<vector<bool>>> memo(N+1,vector<vector<bool>>(N+1,vector<bool>(N+1)));
cout<<setprecision(14)<<solve(dp,memo,a,b,c,N)<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define mp make_pair
#define PI pair<ll,ll>
#define poly vector<ll>
#define mem(a) memset((a),0,sizeof(a))
#define For(i,l,r) for(int i=(int)(l);i<=(int)(r);i++)
#define Rep(i,r,l) for(int i=(int)(r);i>=(int)(l);i--)
#define pb push_back
#define fi first
#define se second
#define SZ(x) ((int)(x.size()))
#define re resize
#define PB pop_back
inline char gc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
#define gc getchar
inline ll read(){
ll x = 0; char ch = gc(); bool positive = 1;
for (; !isdigit(ch); ch = gc()) if (ch == '-') positive = 0;
for (; isdigit(ch); ch = gc()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(ll a){
if(a<0){
a=-a; putchar('-');
}
if(a>=10)write(a/10);
putchar('0'+a%10);
}
inline void writeln(ll a){write(a); puts("");}
inline void wri(ll a){write(a); putchar(' ');}
ll rnd(){
ull ans=0;
For(i,0,4)ans=ans<<15^rand();
return ans%((ull)1<<63);
}
const ll fm=1e9;
int n;
ll ans;
map<pair<PI,PI>,ll> M;
bool zc(PI a,PI b){
return a.fi>=b.fi&&a.se>=b.se;
}
bool bao(pair<PI,PI> a,pair<PI,PI> b){
return zc(a.fi,b.se)&&zc(b.fi,a.se);
}
PI get(ll t){
PI a=mp(0,0);
while(t%2==0){
t/=2; a.fi++;
}
while(t%5==0){
t/=5; a.se++;
}
return a;
}
int main(){
#ifdef Brollan
freopen("1.in","r",stdin);
#endif
n=read();
For(i,1,n){
ll a;
cin>>a;
a=a*fm;
if(getchar()=='.'){
ll b=0;
string s;
cin>>s;
For(j,0,s.size()-1)b=b*10+s[j]-'0';
For(j,1,9-s.size())b*=10;
a+=b;
}
ll x=a,gc=__gcd(x,fm),y=fm/gc;
x/=gc;
PI X=get(x),Y=get(y);
M[mp(X,Y)]++;
if(y==1)ans--;
}
for(auto i:M){
for(auto j:M)if(bao(i.fi,j.fi)){
ans+=i.se*j.se;
}
}
cout<<ans/2<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int n;
string s;
cin >> n >> s;
vector<int> a(n);
for(int i = 0; i < n; i++){
if(s[i] == 'R') a[i] = 0;
if(s[i] == 'G') a[i] = 1;
if(s[i] == 'B') a[i] = 2;
}
vector<ll> cnt(3);
for(int i = 0; i < n; i++){
cnt[a[i]]++;
}
ll ans = 1;
for(int i = 0; i < 3; i++){
ans *= cnt[i];
}
for(int j = 0; j < n; j++){
for(int i = 0; i < j; i++){
int k = j + (j - i);
if(k < n){
if(a[i] == a[j]) continue;
if(a[i] == a[k]) continue;
if(a[k] == a[j]) continue;
ans--;
}
}
}
cout << ans << endl;
return 0;
} | 0 |
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);++i)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;--i)
#define ENDL '\n'
typedef pair<int,int> Pi;
typedef pair<ll,ll> PL;
constexpr ll mod = 1000000007;
constexpr ll INF = 1000000099;
constexpr ll LINF = (ll)(1e18 +99);
const vector<ll> dx={-1,1,0,0},dy={0,0,-1,1};
template<typename T,typename U> inline bool chmin(T& t, const U& u){if(t>u){t=u;return 1;}return 0;}
template<typename T,typename U> inline bool chmax(T& t, const U& u){if(t<u){t=u;return 1;}return 0;}
template<typename T> inline T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T,typename Y> inline T mpow(T a, Y n) {
T res = 1;
for(;n;n>>=1) {
if (n & 1) res = res * a;
a = a * a;
}
return res;
}
signed main(){
cin.tie(0);ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
ll n,m;cin>>n>>m;
VV<int> e(n,V<int>(0));
rep(i,0,m){
int a,b;cin>>a>>b;
a--;b--;
e[a].pb(b);
e[b].pb(a);
}
V<int> flag(n,-1);
queue<int> q;
q.push(0);
flag[0]=0;
q.push(0);
q.push(-1);
while(q.size()){
int now=q.front();q.pop();
int dis=q.front();q.pop();
int pre=q.front();q.pop();
for(auto&& i:e[now]){
if(i==pre)continue;
if(flag[i]==-1){
q.push(i);
flag[i]=dis^1;
q.push(dis^1);
q.push(now);
}else if(flag[i]^(dis^1)){
cout<<n*(n-1)/2 -m<<ENDL;
return 0;
}
}
}
ll x,y;x=y=0;
rep(i,0,n){
if(flag[i]==0)x++;
else y++;
}
cout<<x*y-m<<ENDL;
}
//! ( . _ . ) !
//CHECK overflow,vector_size,what to output? | #include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=5e5+5;
const int M=(1<<20)+5;
const int p=1e9+7;
int read()
{
int s=0;
char c=getchar(),lc='+';
while (c<'0'||'9'<c) lc=c,c=getchar();
while ('0'<=c&&c<='9') s=s*10+c-'0',c=getchar();
return lc=='-'?-s:s;
}
void write(int x)
{
if (x<0)
{
putchar('-');
x=-x;
}
if (x<10) putchar(x+'0');
else
{
write(x/10);
putchar(x%10+'0');
}
}
void print(int x,char c='\n')
{
write(x);
putchar(c);
}
void add(int &x,int y)
{
x+=y;
if (x>=p) x-=p;
}
int sum1[M],sum2[M],dp[N],s[N],x[N];
signed main()
{
x[0]=s[0]=0;
memset(sum1,0,sizeof(sum1));
memset(sum2,0,sizeof(sum2));
int n=read();
dp[0]=1;
sum1[0]=1;
for (int i=1;i<=n;i++)
{
x[i]=x[i-1]^read();
s[i]=s[i-1]+(x[i]==0);
dp[i]=((s[i-1]*sum1[x[i]]-sum2[x[i]]+1)%p+p)%p;
add(sum1[x[i]],dp[i]);
add(sum2[x[i]],dp[i]*s[i]%p);
}
if (x[n]) print(dp[n]);
else
{
int ans=dp[n];
for (int i=1;i<=n;i++) if (x[i]) add(ans,dp[i]);
print(ans);
}
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main(){
int i,j,h,w,minh,minw;
while(1){
int result;
int resultmin=100000000;
cin >> h >> w;
if(h==0 && w==0)break;
int original = h*h+w*w;
int original_minh = h;
int flag = 0;
for( i = 1;i < 150; i++ ){
for( j = i+1; j <=150; j++ ){
result = i*i+j*j;
if( result > original && result < resultmin ){
resultmin = result;
minh=i;
minw=j;
}
if( result == original && i > original_minh ){
minh=i;
minw=j;
flag = 1;
break;
}
}
if( flag == 1 ) break;
}
cout << minh << " " << minw << endl;
}
return 0;
} | #include <stdio.h>
int main() {
int a, b;
scanf("%d %d", &a, &b);
if(a < 10) {
a = 100 * (10 - a);
b = b + a;
printf("%d", b);
} else {
printf("%d", b);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); i++)
#define ll long long
using namespace std;
int main() {
ll N = 0, A,B;;
cin >> N >> A >> B;
if(N == 1){
cout << "Hello World";
}
else{
cout << A + B;
}
}
| /*
ID: anonymo14
TASK: wormhole
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {//227
int n;
cin>>n;
if(n==1)cout<<"Hello World";
else {
int a,b;
cin>>a>>b;
cout<<a+b;
}
}
int main() {
////// FILE BASED IO////
//freopen("wormhole.in", "r", stdin);
//freopen("wormhole.out", "w", stdout);
///////////////
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
//cin>>t;
REP(i,1,t) {
solve(i);
}
return 0;
}
| 1 |
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int dp[34];
int main(){
int N,x;
cin >> x;
dp[0] = 1;
for(int i = 0; i < 31; i++){
dp[i+1] += dp[i];
dp[i+2] += dp[i];
dp[i+3] += dp[i];
}
while(x != 0){
cout << dp[x]/3650 + 1 << endl;;
cin >> x;
}
return 0;
} | #include<iostream>
using namespace std;
int main(){
while(1){
int n;
cin>> n;
if(n==0) break;
int dp[31];
fill(dp, dp+31, 0);
dp[1]=1; dp[2]=2; dp[3]=4;
for(int i=4; i<=n; i++){
dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
}
cout<< (dp[n]+3650-1)/3650<< endl;
}
return 0;
} | 1 |
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
#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(){
map<string, lli > ans;
ans["SUN"]=7;
ans["MON"]=6;
ans["TUE"]=5;
ans["WED"]=4;
ans["THU"]=3;
ans["FRI"]=2;
ans["SAT"]=1;
string s;
cin>>s;
out(ans[s]);
} | #include <bits/stdc++.h>
using namespace std;
void solve(std::string S){
vector<string> yobi = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
for(int i = 0; i < yobi.size(); ++i){
if(yobi[i] == S){
cout << 7 - i << endl;
break;
}
}
}
int main(){
std::string S;
std::cin >> S;
solve(S);
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int,pii> pip;
typedef vector<pip>vip ;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int n,m;
vvi in;
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
int out;
void f(int x,int y,int c){
if(c==10)return;
rep(i,4){
int nx=x,ny=y;
// cout<<nx<<" "<<ny<<endl;
while(1){
nx+=dx[i];ny+=dy[i];
if(nx<0||ny<0||nx>=n||ny>=m)break;
if(in[x+dx[i]][y+dy[i]]==1)break;
if(in[nx][ny]==3){
out=min(out,c+1);
return;
}
if(in[nx][ny]==1){
in[nx][ny]=0;
f(nx-dx[i],ny-dy[i],c+1);
in[nx][ny]=1;
break;
}
}
}
}
int main(){
while(cin>>m>>n,n+m){
out=inf;
in=vvi(n,vi(m));
rep(i,n)rep(j,m)cin>>in[i][j];
rep(i,n)rep(j,m)if(in[i][j]==2){
f(i,j,0);
if(out!=inf)cout<<out<<endl;
else cout<<-1<<endl;
goto end;
}
end:;
}
} | #include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <sstream>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#define rep(i, n) for(int i = 0; i < n; i ++)
#define COUNT(i, n) for(int i = 1; i <= n; i ++)
#define ITER(c) __typeof((c).begin())
#define each(c, it) for(ITER(c) it =(c).begin(); it!=(c).end(); it++)
#define ALL(c) c.begin(), c.end()
#define mp make_pair
#define pb push_back
#define MEMSET(v, h) memset((v), h, sizeof(v))
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
const int INF = 1 << 24;
int main(void){
for(int n, m, s; s = 0, cin >> n >> m, n; cout << s << endl){
priority_queue<int> p;
rep(i, n){
int in; cin >> in;
p.push(in);
}
COUNT(i, n){
if(i % m) s += p.top();
p.pop();
}
}
return 0;
} | 0 |
#include<iostream>
#include<cstring>
#include<cstdio>
#define MN 1000000
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
char s[MN+5],t[MN+5];
int last[MN+5][26],a[MN+5],n,ans=0;
int main()
{
n=read();
scanf("%s%s",s+1,t+1);
for(int i=1;i<=n;++i)
{
memcpy(last[i],last[i-1],sizeof(last[0]));
last[i][s[i]-'a']=i;
}
for(int i=n,j=n,r=0,k=0;i;--i)
{
if(j>i) j=i;
if(s[j]!=t[i])
{
if(!last[j][t[i]-'a']) return 0*puts("-1");
j=last[j][t[i]-'a'];
++r;++k;ans=max(ans,k);
++a[j+r];
}
k-=a[i+r];a[i+r]=0;
}
cout<<ans;
return 0;
}
| #include <cstdio>
using namespace std;
#define REP(a,b,c) for(int a=b;a<=c;++a)
#define RREP(a,b,c) for(int a=b;a>=c;--a)
char s[1000005],t[1000005];
int n,x[1000005],l,r,ans,q,j;
int main() {
scanf("%d%s%s",&n,s+1,t+1);
j=n; l=1; r=0; ans=0; q=0;
RREP(i,n,1) {
if(j>i) --j;
if(s[j]==t[i]) continue;
while(j&&s[j]!=t[i]) --j;
if(!j) {puts("-1"); return 0;}
--q; x[++r]=j-q; while(l<=r&&x[l]+q>=i) ++l;
if(r-l>=ans) ans=r-l+1;
} printf("%d\n",ans); return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B;
cin >> N;
if(N == 1) cout << "Hello World" << endl;
else {
cin >> A >> B;
cout << A+B << endl;
}
} | #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#define rep(i,n) for (int i = 0;i < (n);i++)
#define all(v) v.begin(),v.end()
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b , a % b);
}
ll mod(ll a){
return (a % 1000000007);
}
ll lcm(ll a,ll b){
return (a*b)/gcd(a,b);
}
int main(){
ll n; cin >> n; ll a,b; cin >> a >> b;
if(n==1) cout << "Hello World" << endl;
else cout << a+b << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const ll MOD = 1000000007;
const string V = "Vacant";
int main() {
ll N;
cin >> N;
string l, r;
cout << 0 << endl << flush;
cin >> l;
cout << endl;
if (l == V) return 0;
cout << N - 1 << endl << flush;
cin >> r;
cout << endl;
if (r == V) return 0;
int l_num = 0, r_num = N - 1;
while (true) {
int mid_num = (l_num + r_num) / 2;
string mid;
cout << mid_num << endl << flush;
cin >> mid;
cout << endl;
if (mid == V) return 0;
int num = mid_num - l_num;
if (num % 2 == 1 && mid == l) {
r_num = mid_num;
r = mid;
continue;
} else if (num % 2 == 0 && mid != l) {
r_num = mid_num;
r = mid;
continue;
}
l = mid;
l_num = mid_num;
}
} | #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); }
vector<string> v;
void init() { rep(i, 0, 7) cin >> v[i]; }
string test(int i) { return v[i]; }
int main() {
int n;
cin >> n;
int maxs = 19, mid = 0, head = 0, tail = n - 1;
string old_input, input;
cout << 0 << endl;
cin >> input;
old_input = input;
// v.resize(n);
// init();
// old_input = input = test(0);
if (input == "Vacant")
return 0;
while (maxs--) {
mid = head + ((tail + 1) - head) / 2;
cout << mid << endl;
cin >> input;
// input = test(mid);
if (input == "Vacant")
return 0;
if ((mid - head) & 1) {
if (old_input == input) {
tail = mid;
} else {
head = mid;
old_input = input;
}
} else {
if (old_input == input) {
head = mid;
old_input = input;
} else {
tail = mid;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for(int i = 0; i < n; ++i)
using namespace std;
template <typename T>
bool PN(T x){ if (x <= 1) return false; if (x == 2) return true; for (int i = 2; i < sqrt(x) + 1; i++) if (x % i == 0) return false; return true;}
const ll MOD = 1e9+7;
long long Comb(int n, int i){long long ans = 1; if(i>n || i < 0) return 0; if(i == 0 || i == n) return 1; else {for(int j = 1; j <= i; ++j){
ans *=(n+1-j);
ans /= j;
ans %= MOD;} }return ans;}
template<typename T> T gcd(T a, T b){if(b == 0) return a;else return gcd(b, a%b);}
template<typename T> T lcm(T a, T b){if(b > a) swap(a, b); T g = gcd(a, b);return a / g * b;
}
void solve() {
int n; cin >> n;
map<ll,ll, greater<ll>> mp;
rep(i, n) {
ll tmp;
cin >> tmp;
mp[tmp]++;
}
int cnt = 0;
ll ans = 1;
for(auto p: mp){
if(p.second >= 4 && cnt == 0) {
ans = p.first * p.first;
cnt = 2;
break;
} else if (p.second >= 2 && cnt == 1) {
ans *= p.first;
cnt++;
break;
} else if(p.second >= 2 && cnt == 0) {
ans *= p.first;
cnt++;
}
}
if(cnt <= 1) cout << 0 << endl;
else cout << ans << endl;
}
int main(void){
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int main() {
ll N, a, H = 0, W = 0;
cin >> N;
vector<int> A(N);
for(int i=0; i<N; i++) cin >> A[i];
sort(A.begin(), A.end());
for(int i=N-1; i>=1; i--) {
if(A[i] == A[i-1]) {
if(H == 0) H = A[i];
else if(W == 0) W = A[i];
else break;
i--;
}
}
cout << H * W << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
template<typename T>
ostream& operator<<(ostream &os, vector<T> &v){
string sep = " ";
if(v.size()) os << v[0];
for(int i=1; i<v.size(); i++) os << sep << v[i];
return os;
}
template<typename T>
istream& operator>>(istream &is, vector<T> &v){
for(int i=0; i<v.size(); i++) is >> v[i];
return is;
}
#ifdef DBG
void debug_(){ cout << endl; }
template<typename T, typename... Args>
void debug_(T&& x, Args&&... xs){
cout << x << " "; debug_(forward<Args>(xs)...);
}
#define dbg(...) debug_(__VA_ARGS__)
#else
#define dbg(...)
#endif
void solve(){
int n; cin >> n;
vector<ll> a(n); cin >> a;
string s; cin >> s;
vector<ll> b;
for(int i=n-1; i>=0; i--){
ll x = a[i];
for(ll y: b){
x = min(x, y^x);
}
if(s[i]=='0'){
if(x) b.push_back(x);
} else {
if(x){
cout << 1 << endl;
return;
}
}
}
cout << 0 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(20) << fixed;
int t; cin >> t;
for(int i=0; i<t; i++) solve();
return 0;
}
| #include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <functional>
#include <cmath>
#include <set>
#include <queue>
#include <deque>
#include <vector>
#include <climits>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
template <typename T>
struct RollingHash
{
int size;
int n;
ll factor = 1;
ll b = 0;
ll mod = 0;
ll hash = 0;
vector<T> list;
int num = 0;
int head = 0;
void init(int _n, ll _b = (ll)1e8 + 7, ll _mod = (ll)1e9 + 7)
{
n = _n;
b = _b;
list.reserve(n);
mod = _mod;
auto temp = 1ll;
for (auto i = 0; i < n; ++i)
{
factor = temp;
temp = temp * b % mod;
}
}
void add(ll val)
{
if ((int)list.size() >= n)
{
hash = (((hash - list[head] * factor) % mod) + mod) % mod;
list[head] = val;
head = (head + 1) % n;
}
else
{
list.push_back(val);
}
hash = hash * b % mod;
hash = (hash + val) % mod;
}
ll getHash() { return hash; }
};
int main()
{
int N;
cin >> N;
vector<ll> a(N);
vector<ll> b(N);
for (auto i = 0; i < N; ++i)
{
ll temp;
cin >> temp;
a[i] = temp;
a.push_back(temp);
}
for (auto& temp : b)
{
cin >> temp;
}
vector<ll> x;
for (auto i = 0; i < N; ++i)
{
x.push_back(b[0] ^ a[i]);
}
auto bitNum = 31;
auto mod = (ll)1e9 + 7;
vector<ll> rollingHashFactor = { (ll)1e8 + 7 };
vector<vector<vector<RollingHash<ll>>>> hashA
(bitNum, vector<vector<RollingHash<ll>>>(2, vector<RollingHash<ll>>((int)rollingHashFactor.size())));
vector<vector<RollingHash<ll>>> hashB
(bitNum, vector<RollingHash<ll>>((int)rollingHashFactor.size()));
for (auto i = 0; i < bitNum; ++i)
{
for (auto k = 0; k < N; ++k)
{
auto val = (b[k] >> i) & 1;
for (auto l = 0; l < (int)rollingHashFactor.size(); ++l)
{
if (k == 0)
{
hashB[i][l].init(N, rollingHashFactor[l], mod);
}
hashB[i][l].add(val);
}
}
}
for (auto i = 0; i < bitNum; ++i)
{
for (auto j = 0; j < 2; ++j)
{
for (auto k = 0; k < N; ++k)
{
auto val = ((a[k] >> i) ^ j) & 1;
for (auto l = 0; l < (int)rollingHashFactor.size(); ++l)
{
if (k == 0)
{
hashA[i][j][l].init(N, rollingHashFactor[l]);
}
hashA[i][j][l].add(val);
}
}
}
}
vector<pair<int, ll>> ans;
for (auto k = 0; k < N; ++k)
{
auto match = true;
for (auto i = 0; i < bitNum; ++i)
{
int j = (x[k] >> i) & 1;
for (auto l = 0; l < (int)rollingHashFactor.size(); ++l)
{
if (hashB[i][l].getHash() != hashA[i][j][l].getHash())
{
match = false;
break;
}
}
if (match == false)
{
break;
}
}
if (match != false)
{
ans.push_back({ k, x[k] });
}
for (auto i = 0; i < bitNum; ++i)
{
for (auto j = 0; j < 2; ++j)
{
auto val = ((a[k + N] >> i) ^ j) & 1;
for (auto l = 0; l < (int)rollingHashFactor.size(); ++l)
{
hashA[i][j][l].add(val);
}
}
}
}
for (auto& pair : ans)
{
cout << pair.first << " " << pair.second << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef pair<int, int> P;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
ll mod = 1000000007;
int main(){
int n; cin >> n;
vector <ll> a(n);
rep(i, n){
cin >> a[i];
a[i]++;
}
vector <ll> num(n+1);
num[0] = 3;
ll ans = 1;
rep(i, n){
if (num[a[i]-1] < 0){
cout << 0 << endl;
return 0;
}
ans *= num[a[i]-1];
ans %= mod;
num[a[i]-1]--;
num[a[i]]++;
}
cout << ans <<endl;
} | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author rahdirigs
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <typename T> void s_max(T& a, T b) {
if (a < b) {
a = b;
}
}
class TaskU {
public:
int N;
vector<vector<int>> a;
vector<ll> dp, scores;
vector<int> rem;
void solve(std::istream& in, std::ostream& out) {
in >> N;
a.resize(N, vector<int> (N));
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
in >> a[i][j];
}
}
scores.resize(1 << N, 0);
dp.resize(1 << N, 0);
pre_calc();
for (int mask = 0; mask < (1 << N); mask++) {
rem.clear();
for (int i = 0; i < N; i++) {
if (!(mask & (1 << i))) rem.push_back(i);
}
rec(0, dp[mask], mask, 0);
}
out << dp[(1 << N) - 1];
}
void pre_calc() {
for (int mask = 0; mask < (1 << N); mask++) {
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if ((mask & (1 << i)) && (mask & (1 << j)))
scores[mask] += a[i][j];
}
}
}
}
void rec(int pos, ll score, int mask, int group) {
if (pos == (int) rem.size()) {
s_max(dp[mask], score + scores[group]);
return;
}
rec(pos + 1, score, mask ^ (1 << rem[pos]), group ^ (1 << rem[pos]));
rec(pos + 1, score, mask, group);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
TaskU solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
int main()
{
int R;
cin >> R;
if (R < 1200)
cout << "ABC" << endl;
else if (R < 2800)
cout << "ARC" << endl;
else
cout << "AGC" << endl;
return 0;
}
| #include<iostream>
#include<stdio.h>
using namespace std;
bool include_3(int);
int main(){
int n,i;
cin>>n;
for(i=1;i<=n;i++){
if(i%3==0||include_3(i)){
cout<<" "<<i;
}
}
cout<<endl;
return 0;
}
bool include_3(int n){
while(n){
if(n%10==3){
return 1;
}
n=n/10;
}
return 0;
} | 0 |
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <queue>
const int MAXN = 1e6 + 10;
class no_solution: std::exception
{
public:
const char * what() const noexcept
{
return "There is no solution under such constrains";
}
};
int len;
char a[MAXN], b[MAXN];
auto findSolution() -> std::deque<int>::size_type
{
std::deque<int>::size_type answer = 0;
std::deque<int> DQ;
DQ.push_back(len + 1);
int k = len + 1, offset = 0;
for (int i = len; i > 0; i--)
{
int t = k;
k = std::min(i, k);
while (k && a[k] != b[i])
k--;
if (k <= 0)
throw no_solution();
if (k == t)
{
while (!DQ.empty() && DQ.back() + offset >= i)
DQ.pop_back();
DQ.push_back(i - offset);
}
else
{
offset--;
if (i != k)
answer = std::max(answer, DQ.size()), DQ.push_front(k - offset);
}
}
return answer;
}
int main()
{
std::cin >> len >> (a+1) >> (b+1) ;
try
{
std::cout << findSolution() << std::endl ;
}
catch(no_solution & x)
{
std::cout << "-1" << std::endl ;
std::cerr << x.what() << std::endl ;
}
return 0;
}
| #include <cstdio>
using namespace std;
double l[10],v1, v2;
int main()
{
loop:
while ( scanf("%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf\n", &l[0], &l[1], &l[2], &l[3], &l[4], &l[5], &l[6], &l[7], &l[8], &l[9], &v1, &v2 ) != EOF )
{
v2 += v1;
for( int i = 0; i < 10; i++ )
{
l[i] += ( ( i == 0 ) ? 0 : l[i - 1] );
}
double t = l[9] / v2;
double dis = v1 * t;
for( int i = 0; i < 10; i++ )
{
if( dis == l[i] )
{
printf( "%d\n", i + 1 );
goto loop;
}
else if( dis < l[i] )
{
printf( "%d\n", i + 1 );
goto loop;
}
}
/* for( int i = 0; i < 10; i++ )
{
if( l[i] <= dis && dis <= l[i + 1] )
{
printf( "%d\n", i + 2 );
return 0;
}
} */
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define MAXN 100005
using namespace std;
int n, k, a[MAXN], dep[MAXN], sum[MAXN], adv[MAXN], fa[MAXN], ans;
vector<int> g[MAXN];
int read() {
char c = getchar();
int x = 0;
while (!isdigit(c))
c = getchar();
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x;
}
int DFS(int u) {
int maxi = dep[u];
for (int i = 0; i < (int)g[u].size(); ++i) {
int v = g[u][i];
if (v == 1)
continue;
dep[v] = dep[u] + 1;
maxi = max(DFS(v), maxi);
}
if (maxi - dep[u] == k - 1) {
if (maxi > k)
++ans;
return dep[u] - 1;
}
return maxi;
}
int main() {
n = read();
k = read();
for (int i = 1; i <= n; ++i) {
fa[i] = read();
g[fa[i]].push_back(i);
}
DFS(1);
ans += fa[1] != 1;
printf("%d\n", ans);
}
| #include <cstdio>
typedef long long ll;
#define ri register int
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
// getchar
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
// print the remaining part
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
// putchar
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
// input a signed integer
template <class I>
inline void gi (I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = (x << 1) + (x << 3) + (c & 15); x *= f;
}
// print a signed integer
template <class I>
inline void print (I x) {
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
}
//no need to call flush at the end manually!
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: gi;
using io :: putc;
using io :: print;
const int N=605;
int n,m,col1[N][N],col2[N][N],tag[2][2];
inline void solve(ri d,int col[N][N]){
ri i,j,k;
k=0;
while(d%4==0) d>>=2,++k;
if(d&1){
for(i=0;i<m;++i)
for(j=0;j<m;++j)
if((i>>k)+(j>>k)&1)
col[i][j]=1;
}
else{
for(i=0;i<m;++i)
for(j=0;j<m;++j)
if((i>>k)&1)
col[i][j]=1;
}
}
int main(){
ri d1,d2,i,j,x,y,cnt;
gi(n);gi(d1);gi(d2);
m=n<<1;
solve(d1,col1);
solve(d2,col2);
for(i=0;i<m;++i)
for(j=0;j<m;++j)
++tag[col1[i][j]][col2[i][j]];
for(i=0;i<=1;++i)
for(j=0;j<=1;++j)
if(tag[i][j]>=n*n){
cnt=0;
for(x=0;x<m;++x)
for(y=0;y<m;++y)
if(col1[x][y]==i&&col2[x][y]==j){
print(x);putc(' ');print(y);putc('\n');
if(++cnt==n*n) return 0;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef pair<int, int> P;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
ll mod = 1000000007;
int main(){
int n; cin >> n;
vector <ll> a(n);
rep(i, n){
cin >> a[i];
a[i]++;
}
vector <ll> num(n+1);
num[0] = 3;
ll ans = 1;
rep(i, n){
if (num[a[i]-1] < 0){
cout << 0 << endl;
return 0;
}
ans *= num[a[i]-1];
ans %= mod;
num[a[i]-1]--;
num[a[i]]++;
}
cout << ans <<endl;
} | #include<algorithm>
#include<iostream>
#include<vector>
#include<string>
#define rep(i, start, end) for (int i = (int)start; i < (int)end; ++i)
#define rrep(i, start, end) for (int i = (int)start - 1; i >= (int)end; --i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
template<typename T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return true;} return 0;}
template<typename T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return true;} return 0;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N), B(N);
for (auto& a : A) {
cin >> a;
}
for (auto& b : B) {
cin >> b;
}
vector<int> cnt(N + 1, 0);
for (auto& a : A) {
++cnt[a];
}
for (auto& b : B) {
++cnt[b];
}
rep(i, 0, N) {
if (cnt[i + 1] > N) {
cout << "No" << endl;
return 0;
}
}
reverse(all(B));
int same_val = 0;
rep(i, 0, N) {
if (A[i] == B[i]) {
same_val = A[i];
break;
}
}
if (same_val) {
vector<int> idx_buf;
rep(i, 0, N) {
if (B[i] != same_val && A[i] != same_val) {
idx_buf.push_back(i);
}
}
rep(i, 0, N) {
if (A[i] == B[i]) {
int target = idx_buf.back();
idx_buf.pop_back();
swap(B[i], B[target]);
}
}
}
cout << "Yes" << endl;
rep(i, 0, N) {
cout << B[i] << " \n"[i + 1 == N];
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll,int> plli;
typedef pair<double, int> pdbi;
typedef pair<int,pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1<<30;
const ll mod = 1000000000 + 7;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
//#define int long long
#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int cnt[n] = {};
rep(i, n * (n - 1) / 2) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a--; b--;
if (c > d) cnt[a] += 3;
else if (c == d) {
cnt[a]++;
cnt[b]++;
}
else cnt[b] += 3;
}
int score[305] = {};
rep(i, n) score[cnt[i]]++;
int total[305] = {};
rrep2(i, 303, 0) {
total[i] = total[i + 1] + score[i];
}
rep(i, n) {
cout << total[cnt[i]] - score[cnt[i]] + 1 << endl;
}
} | #include <iostream>
#include <string>
#include <cstring>
#include <sstream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
using namespace std;
class cLSearch
{
int mn, mq;
string mS, mT;
vector<int> vs, vt;
int ans;
void decode();
public:
cLSearch(const int &n, const int &q, const string &s, const string &t)
{
mn = n;
mq = q;
mS = s;
mT = t;
decode();
}
void search();
void output();
};
void cLSearch::search()
{
sort(vs.begin(), vs.end());
sort(vt.begin(), vt.end());
int count = 0;
vector<int>::iterator vis = vs.begin();
vector<int>::iterator vit = vt.begin();
int ts, tt;
while (vis != vs.end() && vit != vt.end())
{
if (*vis == *vit)
{
++count;
ts = *vis;
tt = *vit;
while (vis != vs.end() && ts == *vis)
++vis;
while (vit != vt.end() && tt == *vit)
++vit;
}
else
{
if (vis != vs.end() && vit != vt.end() && *vis > *vit)
++vit;
else
++vis;
}
}
ans = count;
}
void cLSearch::output()
{
cout << ans << endl;
}
void cLSearch::decode()
{
istringstream iss;
iss.str(mS);
int ts;
for (int i = 0; i < mn; ++i)
{
iss >> ts;
vs.push_back(ts);
}
iss.str(mT);
iss.seekg(0, iss.beg);
for (int i = 0; i < mq; ++i)
{
iss >> ts;
vt.push_back(ts);
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
string s, t;
cin >> n;
cin.ignore();
getline(cin, s);
cin >> q;
cin.ignore();
getline(cin, t);
cLSearch cls(n, q, s, t);
cls.search();
cls.output();
return 0;
} | 0 |
#include <stdio.h>
typedef long long ll;
ll abs(ll a) {
return a > 0 ? a : -a;
}
int main(void) {
ll i, j, k, h, w;
scanf("%lld%lld", &h, &w);
ll a[h][w], b[h][w], d[h][w];
bool dp[w][80 * (h + w)], tmp[w][80 * (h + w)];
for(j = 0; j < w; ++j) for(k = 0; k < 80 * (h + w); ++k) dp[j][k] = false;
for(i = 0; i < h; ++i) for(j = 0; j < w; ++j) scanf("%lld", &a[i][j]);
for(i = 0; i < h; ++i) for(j = 0; j < w; ++j) scanf("%lld", &b[i][j]), d[i][j] = abs(a[i][j] - b[i][j]);
for(i = 0; i < w; ++i) for(j = 0; j < 80 * (h + w); ++j) dp[i][j] = false;
dp[0][d[0][0]] = true;
for(i = 1; i < w; ++i) for(j = 0; j < 80 * (h + w); ++j) if(dp[i - 1][j]) {
dp[i][j + d[0][i]] = true;
dp[i][abs(j - d[0][i])] = true;
}
for(k = 1; k < h; ++k) {
for(i = 0; i < w; ++i) for(j = 0; j < 80 * (h + w); ++j) tmp[i][j] = false;
for(i = 0; i < 80 * (h + w); ++i) if(dp[0][i]) {
tmp[0][i + d[k][0]] = true;
tmp[0][abs(i - d[k][0])] = true;
}
for(i = 1; i < w; ++i) for(j = 0; j < 80 * (h + w); ++j) {
if(tmp[i - 1][j]) {
tmp[i][j + d[k][i]] = true;
tmp[i][abs(j - d[k][i])] = true;
}
if(dp[i][j]) {
tmp[i][j + d[k][i]] = true;
tmp[i][abs(j - d[k][i])] = true;
}
}
for(i = 0; i < w; ++i) for(j = 0; j < 80 * (h + w); ++j) dp[i][j] = tmp[i][j];
}
for(i = 0; ; ++i) if(dp[w - 1][i]) {
printf("%lld", i);
return 0;
}
} | #include <bits/stdc++.h>
#include<iostream>
#include<vector>
#include<map>
#include<math.h>
#define irep(i,n) for(int i = 0; i < (int)(n); i++)
#define irep2(i,a,n) for(int i = (int)(a); i <= (int)(n); i++)
#define irrep(i,n) for(int i = (int)(n-1); i > -1; i--)
#define irrep2(i,n,a) for(int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using namespace std;
using ll = long long;
using v_int = vector<int>;
using v2_int = vector<v_int>;
using v_ll = vector<ll>;
using v2_ll = vector<v_ll>;
using v_string = vector<string>;
using v_bool = vector<bool>;
using v2_bool = vector<v_bool>;
using pii = pair<int, int>;
using mii = map<int, int>;
const double PI = 3.1415926535897932;
const int INF = (int)2e9;
const ll LINF = (ll)2e18;
const ll MOD = 1000000007;
const int dc[8] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dr[8] = {0, 0, 1, -1, 1, 1, -1, -1};
template<typename T, typename U> inline
ostream& operator<<(ostream &o, pair<T,U> &p) {
return o << "{" << p.first << "," << p.second << "}";
}
template<typename T> inline
istream& operator>>(istream &is, vector<T> &vec) {
for(auto &v : vec) { is >> v; }
return is;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<T> &vec) {
for(auto &v : vec) { os << v << ",";}
return os;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<vector<T> > &mat) {
for(auto &row : mat) { os << row << endl; }
return os;
}
template<typename T> inline
void chmin(T &a, T b) { a = min(a, b); }
template<typename T> inline
void chmax(T &a, T b) { a = max(a, b); }
int main(void)
{
int n, l;
cin >> n >> l;
int sum = n * l + n*(n+1)/2 - n;
int ans = INF;
int apple = 0;
irep2(i, 1, n) {
int eat = sum - (l + i - 1);
if(ans > abs(eat-sum)) {
apple = i;
ans = abs(eat-sum);
}
}
cout << sum - (l + apple -1) << endl;
return 0;
} /*atcoder*/
| 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() {
vector<int> X(3);
rep(i,3) cin >> X.at(i);
swap(X.at(0), X.at(1));
swap(X.at(0), X.at(2));
for(auto e:X) cout << e << " ";
cout << endl;
return 0;
}
| //#pragma GCC optimize "trapv"
#include<bits/stdc++.h>
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//find_by_order(k) returns iterator to kth element starting from 0;
//order_of_key(k) returns count of elements strictly smaller than k;
//erase,insert same as normal set
//#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define fast ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define f first
#define s second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define forn(i,n) for(int i=0;i<n;++i)
#define show(b) for(auto const&x: b) cout<<x<<" "
#define sshow(b) for(auto x:b) cout<<x<<" "
#define fix(b,val) memset(b,val,sizeof(b))
#define pill(b,n,v) fill(b,b+n,v)
#define itn int
#define w(t) int t;cin>>t;while(t--)
#define mx(a,b,c) max(a,max(b,c))
#define mn(a,b,c) min(a,min(b,c))
#define intmax INT_MAX
#define intmin INT_MIN
#define nl "\n"
#define prt(val) cout<<val<<"\n"
#define all(v) v.begin(),v.end()
#define trace1(x) cerr<<#x<<": "<<x<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<":" <<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define trace4(a, b, c, d) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl
#define trace5(a, b, c, d, e) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<endl
#define trace6(a, b, c, d, e, f) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<" | "<<#f<<": "<<f<<endl
typedef long long int ll;
typedef long double LD;
typedef unsigned long long int LL;
typedef pair<int,int> pii;
typedef pair<long long int,int> pli;
typedef pair<int,long long int> pil;
typedef pair<long long int,long long int> pll;
const int N=2*1e6+10;
const int mod=1e9+7;
//mt19937 rnd(time(NULL));
/*------Global--------*/
/*-----Functions------*/
template<typename T>
void show2d(const vector<vector<T>>& adj)
{
for(auto x:adj)
{
for(auto y:x)
{
cout<<y<<" ";
}
cout<<"\n";
}
}
ll modexp(ll a,ll b,ll mod)
{
ll x=1;
while(b)
{
if(b&1)
x = ((x%mod) * (a%mod))%mod;
a = ((a%mod) * (a%mod))%mod;
b = b / 2;
}
return x;
}
void rf()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int32_t main()
{
fast;
// rf();
int h1,m1,h2,m2,k;
cin>>h1>>m1>>h2>>m2>>k;
int tot = (h2-h1)*60 + (m2-m1);
tot -= k;
cout<<tot<<nl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fi first
#define se second
int n,ans=0,cnt[5007],id[5007];
long long h[5007],p[5007],dp[5007];
bool cmp(int x,int y){
return (h[x]+p[x]<h[y]+p[y]);
}
int main(){
ios_base::sync_with_stdio(0);
cin>>n;
for(int i=1;i<=n;i++){
cin>>h[i]>>p[i];
id[i]=i;
}
sort(id+1,id+1+n,cmp);
for(int i=1;i<=n;i++) dp[i]=1e16;
dp[0]=0;
for(int i=1;i<=n;i++){
for(int j=i-1;j>=0;j--){
int t=id[i];
if(dp[j]<=h[t]) dp[j+1]=min(dp[j+1],dp[j]+p[t]);
}
}
for(int i=n;i>=0;i--){
if(dp[i]!=1e16){
cout<<i;
return 0;
}
}
}
| #include <iostream>
using namespace std;
void direction(char d, int dice[])
{
int temp;
switch(d)
{
case 'E': temp = dice[1];
dice[1] = dice[4];
dice[4] = dice[6];
dice[6] = dice[3];
dice[3] = temp;
break;
case 'S': temp = dice[1];
dice[1] = dice[5];
dice[5] = dice[6];
dice[6] = dice[2];
dice[2] = temp;
break;
case 'W': temp = dice[1];
dice[1] = dice[3];
dice[3] = dice[6];
dice[6] = dice[4];
dice[4] = temp;
break;
case 'N': temp = dice[1];
dice[1] = dice[2];
dice[2] = dice[6];
dice[6] = dice[5];
dice[5] = temp;
break;
case 'R': temp = dice[2];
dice[2] = dice[3];
dice[3] = dice[5];
dice[5] = dice[4];
dice[4] = temp;
break;
}
return;
}
int main ()
{
int n;
cin >> n;
int dice[n][7], same[n];
for (int i = 0;i < n;i++) same[i] = true;
for (int i = 0;i < n;i++)
{
for (int j = 1;j <= 6;j++)
{
cin >> dice[i][j];
}
}
for (int i = 1;i < n;i++)
{
for(int j = 1;j <= 4;j++)
{
if (dice[i][1] != dice[0][1])
{
direction('N', dice[i]);
}
else break;
}
if (dice[i][1] != dice[0][1])
{
if (dice[i][3] == dice[0][1]) direction('W', dice[i]);
else if (dice[i][4] == dice[0][1]) direction('E', dice[i]);
else same[i] = false;
}
if (same[i])
{
for(int j = 1;j <= 4;j++)
{
if (dice[i][2] != dice[0][2])
{
direction('R', dice[i]);
}
else break;
}
for(int j = 1;j <= 6;j++)
{
if (dice[i][j] != dice[0][j])
{
same[i] = false;
break;
}
}
}
}
int alldiff = true;
for (int i = 1;i < n;i++)
{
if (same[i])
{
alldiff = false;
break;
}
}
if (alldiff) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 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<ll, ll>;
const ll INF = 1LL << 62;
const double PI = acos(-1);
const double eps = 1e-10;
int main() {
ll n, x, y;
cin >> n;
vector<P> red, blue;
vector<bool> is_pair_red(n, false), is_pair_blue(n, false);
rep(i, n) {
cin >> x >> y;
red.emplace_back(y, x);
}
rep(i, n) {
cin >> x >> y;
blue.emplace_back(x, y);
}
sort(red.rbegin(), red.rend());
sort(blue.begin(), blue.end());
ll ans = 0;
rep(i, n) {
rep(j, n) {
if (is_pair_red[j] || is_pair_blue[i]) continue;
int bx = blue[i].first, by = blue[i].second;
int rx = red[j].second, ry = red[j].first;
if (rx < bx && ry < by) {
is_pair_red[j] = true;
is_pair_blue[i] = true;
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
}
| //
// Created by tac on 2016/10/16.
//
#include <algorithm>
#include <cstdlib>
#include <string>
#include <iostream>
namespace {
void print(const std::string &str,
std::string::size_type a,
std::string::size_type b) {
std::cout << str.substr(a, b - a + 1) << std::endl;
return;
}
const std::string reverse(const std::string &str,
std::string::size_type a,
std::string::size_type b) {
std::string ret = str;
std::reverse(ret.begin() + a, ret.begin() + b + 1);
return ret;
}
const std::string replace(const std::string &str,
std::string::size_type a,
std::string::size_type b,
const std::string &rep) {
std::string ret = str;
ret.replace(ret.begin() + a, ret.begin() + (b + 1), rep);
return ret;
}
}
int main() {
std::string str;
int n;
std::string op, rep;
int a, b;
std::cin >> str;
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> op;
std::cin >> a >> b;
if (op == "print") {
print(str, a, b);
} else if (op == "reverse") {
str = reverse(str, a, b);
} else if (op == "replace") {
std::cin >> rep;
str = replace(str, a, b, rep);
} else {
throw std::runtime_error("");
}
}
return EXIT_SUCCESS;
} | 0 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <limits>
#include <iomanip>
#include <vector>
#include <cstring>
#include <queue>
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using uld = unsigned long long;
using P = pair<int,int>;
const ll mod = 1e9+7;
const int dx[4] = {0,1,0,-1};
const int dy[4] = {1,0,-1,0};
template<class T> inline bool chmax(T &a,T& b){if(a < b){a = b; return true;} else return false;}
template<class T> inline bool chmin(T &a,T& b){if(a > b){a = b; return true;} else return false;}
int main(){
int n,x;
cin >> n >> x;
int num[n],cum[n+1]={0};
rep(i,n){
cin >> num[i];
}
sort(num,num+n);
rep1(i,n){
cum[i] = cum[i-1] + num[i-1];
}
int ans = n;
rep(i,n+1){
if(i == n){
if(x != cum[n]){ ans--;}
break;
}
if(cum[i] <= x && x < cum[i+1]){
ans = i;
break;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
#define int long long
signed main() {
int n, x;
cin >> n >> x;
vector<int> a(n);
rep(i,n) cin >> a[i];
sort(a.begin(),a.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if(i == n - 1) {
if(x == a[i]) ans++;
break;
}
if(a[i] <= x) {
x -= a[i];
ans++;
} else {
break;
}
}
cout << ans << endl;
} | 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int dp[101][101];
int r[100],c[100];
int solv(int a,int b){//a??????b-1?????§?????????????????????????????????????????°???????°???¨?????????????????????????????????
if(dp[a][b]==-1){
if(a == b-1){
dp[a][b]=0;
}else if(a==b-2){
dp[a][b]=r[a]*c[a]*c[a+1];
}else{
int Pmin=999999999;
for(int j=a+1;j<b;j++){
int tmp=solv(a,j)+solv(j,b)+r[a]*r[j]*c[b-1];
Pmin=min(Pmin,tmp);
}
dp[a][b]=Pmin;
}
}
return dp[a][b];
}
int main(){
for(int i=0;i<101;i++){
for(int j=0;j<101;j++){
dp[i][j]=-1;
}
}
int N;
cin>>N;
for(int i=0;i<N;i++){
cin>>r[i]>>c[i];
}
int ans=solv(0,N);
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> Vi;
typedef tuple<int, int, int> T;
#define FOR(i,s,x) for(int i=s;i<(int)(x);i++)
#define REP(i,x) FOR(i,0,x)
#define ALL(c) c.begin(), c.end()
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
int mat[110][2], dp[110][110];
const int INF = 1<<29;
int main() {
// use scanf in CodeForces!
cin.tie(0);
ios_base::sync_with_stdio(false);
int N;
cin >> N;
REP(i, N) REP(j, 2) cin >> mat[i][j];
REP(i, N) REP(j, N) dp[i][j] = INF;
REP(i, N) dp[i][i] = 0;
for (int w = 1; w < N; w++) {
for (int L = 0; L + w < N; L++) {
int R = L + w;
for (int i = L; i < R; i++)
dp[L][R] = min(dp[L][R], dp[L][i] + dp[i+1][R] + mat[L][0] * mat[i][1] * mat[R][1]);
}
}
cout << dp[0][N-1] << endl;
return 0;
} | 1 |
Subsets and Splits