code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int main(){
ll S;
cin>>S;
ll digit=0;
ll d=S;
while(d!=0){
digit++;
d/=10;
}
vector<ll> s(digit);
rep(i,digit){
s[i]=S%10;
S/=10;
}
reverse(s.begin(),s.end());
ll ans;
ll cnt;
ll cnt2;
rep(i,digit-2){
cnt=0;
cnt2=0;
cnt=s[i]*100+s[i+1]*10+s[i+2];
cnt2=abs(753-cnt);
if(i==0){
ans=cnt2;
}
if(i>0){
if(cnt2<ans){
ans=cnt2;
}
}
}
cout<<ans<<endl;
} | #include <cstdio>
#include <algorithm>
#include <vector>
#include <utility>
using namespace std;
template <class RandomIt>
RandomIt partition_(RandomIt first, RandomIt last) {
using T=typename RandomIt::value_type;
T x=last[-1];
RandomIt it=first-1;
for (RandomIt it2=first; it2<last-1; ++it2)
if (*it2 <= x) {
++it;
swap(*it, *it2);
}
swap(*++it, last[-1]);
return it;
}
int main() {
size_t n;
scanf("%zu", &n);
vector<int> A(n);
for (size_t i=0; i<n; ++i)
scanf("%d", &A[i]);
vector<int>::iterator pivot=partition_(A.begin(), A.end());
for (vector<int>::iterator it=A.begin(); it<pivot; ++it)
printf("%d ", *it);
printf("[%d] ", *pivot);
for (vector<int>::iterator it=pivot+1; it<A.end(); ++it)
printf("%d%c", *it, it<A.end()-1? ' ':'\n');
return 0;
} | 0 |
#include <iostream>
#include<string>
using namespace std;
class Dice{
public:
int num[6],t;//t=top
/*
dice.num[0] = ???
dice.num[1] = ???
dice.num[2] = ???
dice.num[3] = ???
dice.num[4] = ???
dice.num[5] = ???*/
void North(){
t = num[0];
num[0] = num[1];//??????1?????¨???
num[1] = num[5];//??????2?????¨???
num[5] = num[4];//??????6?????¨???
num[4] = t;//??????5?????¨???
}
void East(){
t = num[0];
num[0] = num[3];//??????1?????¨???
num[3] = num[5];//??????4?????¨???
num[5] = num[2];//??????6?????¨???
num[2] = t;//??????3?????¨???
}
void West(){
t = num[0];
num[0] = num[2];//??????1?????¨???
num[2] = num[5];//??????5?????¨???
num[5] = num[3];//??????6?????¨???
num[3] = t;//??????2?????¨???
}
void South(){
t = num[0];
num[0] = num[4];//??????1?????¨???
num[4] = num[5];//??????3?????¨???
num[5] = num[1];//??????6?????¨???
num[1] = t;//??????3?????¨???
}
void Rotation(){//?????¢??????????????§?????¢???????????¨???
t = num[1];
num[1] = num[2];//?????¢???2?????¨???
num[2] = num[4];//?????¢???3?????¨???
num[4] = num[3];//?????¢???5?????¨???
num[3] = t;//?????¢???4?????¨???
}
};
int main()
{
Dice d[100];
int n;
cin >> n;
for(int i=0; i<n; i++){
cin >> d[i].num[0] >> d[i].num[1] >> d[i].num[2] >> d[i].num[3] >> d[i].num[4] >> d[i].num[5];
}
for(int i=0; i<n; i++){
for(int j=i+1; j<n; j++){
//?????¢??????????????????
if(( d[i].num[2] == d[j].num[0] || d[i].num[3] == d[j].num[0]) && d[i].num[0] != d[j].num[5]){
d[i].East();
}
//?????¢??????????¨???????
for(int k = 0; k<4; k++){
if(d[i].num[0] == d[j].num[0])break;
d[i].North();
}
////?????¢?????????????????????
for(int k = 0; k<4; k++){
if(d[i].num[1] == d[j].num[1])break;
d[i].Rotation();
}
for(int k = 0; k<4; k++){
if(d[i].num[2] == d[j].num[2])break;
d[i].Rotation();
}
for(int k = 0; k<4; k++){
if(d[i].num[3] == d[j].num[3])break;
d[i].Rotation();
}
for(int k = 0; k<4; k++){
if(d[i].num[4] == d[j].num[4])break;
d[i].Rotation();
}
for(int k = 0; k<4; k++){
if(d[i].num[5] == d[j].num[3])break;
d[i].Rotation();
}
if( d[i].num[0] == d[j].num[0] &&
d[i].num[1] == d[j].num[1] &&
d[i].num[2] == d[j].num[2] &&
d[i].num[3] == d[j].num[3] &&
d[i].num[4] == d[j].num[4] &&
d[i].num[5] == d[j].num[5] ){
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
class Dice
{
public:
vector<int> diceNum;
Dice(vector<int>& inputs);
void toW();
void toS();
void ParallelRotation();
};
Dice::Dice(vector<int>& inputs)
{
diceNum=inputs;
}
void Dice::toW()
{
swap(diceNum[0],diceNum[3]);
swap(diceNum[0],diceNum[5]);
swap(diceNum[0],diceNum[2]);
}
void Dice::toS()
{
swap(diceNum[0],diceNum[1]);
swap(diceNum[0],diceNum[5]);
swap(diceNum[0],diceNum[4]);
}
void Dice::ParallelRotation()
{
swap(diceNum[1],diceNum[2]);
swap(diceNum[2],diceNum[4]);
swap(diceNum[4],diceNum[3]);
}
bool Judge(Dice& dice1,Dice& dice2)
{
int count=0;
for(int i=0;i<6;i++)
{
if(dice1.diceNum[i]==dice2.diceNum[i]) count++;
}
if(count==6)return true;
else return false;
}
bool preJudge(Dice& dice1,Dice& dice2)
{
int count=0;
bool flag=false;
while(1)
{
dice2.toS();
for(int j=0;j<4;j++)
{
dice2.ParallelRotation();
flag=Judge(dice1,dice2);
if(flag==true) break;
}
if(flag==true) break;
dice2.toW();
for(int j=0;j<4;j++)
{
dice2.ParallelRotation();
flag=Judge(dice1,dice2);
if(flag==true) break;
}
count++;
if(flag==true) break;
if(count==3)break;
}
return flag;
}
int main(int argc,char* argv[])
{
vector<int> inputs(6);
int number;
int count =0;
cin >> number;
bool flag=false;
vector<Dice> Dices;
for(int i=0;i<number;i++)
{
for(int j=0;j<6;j++)
{
cin >> inputs[j];
}
Dices.push_back(Dice(inputs));
}
for(int i=0;i<number-1;i++)
{
for(int j=i+1;j<number;j++)
{
flag = preJudge(Dices[i],Dices[j]);
if(flag==true) break;
}
if(flag==true) break;
}
if(flag==true) cout << "No" << endl;
else if(flag==false) cout << "Yes" << endl;
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <cmath>
#include <string>
#include <cstring>
#include <sstream>
#include <iomanip>//小数精度 cout << fixed << setprecision(5) << tmp << endl;
using namespace std;
#define ll long long
#define vvi vector< vector<int> >
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define All(X) (X).begin(),(X).end()
const ll int INF =1000000001;
int v,e,r;
struct edge {ll int from,to,cost; };
vector<edge> es(e);
vector<ll int> d(v);
bool find_negative_loop(){
//memset(d,0,sizeof(d));
fill(All(d),0);
REP(i,v){
REP(j,e){
edge e = es[j];
if(d[e.to] > d[e.from] + e.cost){
d[e.to] = d[e.from] + e.cost;
if(i==v-1) return true;
}
}
}
return false;
}
void SearchMinCost(int s){
REP(i,v) d[i] = INF;
d[s] = 0;
while(true){
bool update = false;
REP(i,e){
edge e = es[i];
if(d[e.from]!=INF && d[e.to] > d[e.from] + e.cost ){
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if(!update) break;
}
}
int main(){
cin >> v >> e >> r;
es.resize(e);
REP(i,e) {
cin >> es[i].from >> es[i].to >> es[i].cost;
}
d.resize(v);
SearchMinCost(r);
//if(find_negative_loop()){
// cout <<"NEGATIVE CYCLE"<<endl;
//}else{
SearchMinCost(r);
REP(i,v) {
if(d[i]>=INF) cout << "INF" <<endl;
else cout << d[i] <<endl;
}
//}
return 0;
} | #include <bits/stdc++.h>
using namespace std;using ll=int_fast64_t;using ld=long double;using pll=pair<ll,ll>;using pld=pair<ld,ld>;
const ll INF=1LL<<60;void solve();int main(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(10);solve();}
#define foreach(i,a) for(auto &i:a)
#define SELECTOR(_1,_2,_3,_4,SELECT,...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__,_rep2,_rep1,_rep0)(__VA_ARGS__)
#define _rep0(i,n) for(ll i=0;i<n;++i)
#define _rep1(i,k,n) for(ll i=k;i<n;++i)
#define _rep2(i,k,n,d) for(ll i=k;d!=0&&d>0?i<n:i>n;i+=d)
template<class T> vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
template<class... Ts> auto make_v(size_t a,Ts... ts){return vector<decltype(make_v(ts...))>(a,make_v(ts...));}
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(a>b){a=b; return 1;} return 0;}
void solve(){
ll n; cin>>n;
string S; cin>>S;
ll q; cin>>q;
rep(_,q){
ll k; cin>>k;
vector<ll> DMC(3);
ll cnt=0;
ll ans=0;
queue<char> Q;
foreach(s,S){
// push
if(s=='D'){
DMC[0]++;
}else if(s=='M'){
DMC[1]++;
cnt+=DMC[0];
}else if(s=='C'){
DMC[2]++;
ans+=cnt;
}
Q.push(s);
// pop
if(Q.size()<k) continue;
char t=Q.front(); Q.pop();
if(t=='D'){
DMC[0]--;
cnt-=DMC[1];
}else if(t=='M'){
DMC[1]--;
}else if(t=='C'){
DMC[2]--;
}
}
cout<<ans<<"\n";
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, x, res = 0;
cin >> N >> x;
int a[N];
for (int i = 0; i < N; i++) {
cin >> a[i];
}
sort(a, a+N);
for (int j = 0; j < N; j++) {
if (j == N -1) {
if (x == a[j]) {
res++;
}
break;
}
if (x - a[j] >= 0) {
x -= a[j];
res++;
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define req(i,n) for(int i = 1;i <=n;i++)
#define pai 3.14159265358979323846
const int INF = 1001001001;
typedef long long ll;
int A[3][3], N;
bool punched[3][3];
bool ok[3][3];
using Graph = vector<vector<int>>;
vector<vector<int>> field;
vector<bool> seen;
const int MOD = 1000000007;
typedef pair<int,int> P;
//最大公約数
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 /gcd(a,b) * b;
}
//素数判定
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
// 素因数分解
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
// 10進数から2進数
int binary(int bina){
int ans = 0;
for (int i = 0; bina>0 ; i++)
{
ans = ans+(bina%2)*pow(10,i);
bina = bina/2;
}
return ans;
}
int main() {
int n;
cin >> n;
ll x,a[n+1];
cin >> x;
rep (i,n){
cin >> a[i];
}
int res = 0;
sort (a,a+n);
rep (i,n){
if (x >= a[i]) {
res ++;
x -= a[i];
}
else break;
}
if (res == n && x) --res;
cout << res << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
cout << (n+k-1)/k - n/k << endl;
} |
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << endl;
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, K;
cin >> N >> K;
if (N % K == 0) print(0);
else print(1);
}
| 1 |
#include <iostream>
#include <set>
using namespace std;
int main() {
int n;
cin >> n;
multiset<int> st;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
auto itr = st.lower_bound(a);
if (itr == st.begin()) {
st.insert(a);
} else {
itr--;
st.erase(itr);
st.insert(a);
}
}
int ans = st.size();
cout << ans << endl;
return 0;
} | // Made by Luis Miguel Baez
// [email protected]
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define precise(n,k) fixed << setprecision(k) << n
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define piii pair<int, pair<int, int>>
#define pll pair<ll, ll>
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define debug(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
string to_string(string s) {
return '"' + s + '"';
}
string to_string(bool b) {
return (b ? "true" : "false");
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename T>
string to_string(const vector<T> &v) {
bool first = true;
string res = "{";
for (const T &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string((T)x);
}
res += "}";
return res;
}
// add templates here
template<class T>
void println(const T &data) {
cout << to_string((T)data) << endl;
}
template <typename T>
void write(vector<T> &v, bool size=true) {
if(size) cout << v.size() << endl;
string res = "";
for(const T &x: v) {
res += to_string((T)x) + " ";
}
cout << res << endl;
}
template <typename T>
void read(vector<T> &v) {
for(const T &x: v) {
cin >> x;
}
}
const int MOD = int(1e9+7);
const int oo = int(1e9 + 20);
const ll lloo = (ll)(1e18 + 10);
#define NEUTRAL_MIN -oo
// Limite de la longitud del Array
const int N = 100000 + 20;
int n; // Tamaño del Arreglo
// Maximo Tamaño del Arbol
int tree[2 * N];
// Funcion que Construye el Arbol
void build( vector<int> arr) {
for (int i=0; i<n; i++){
tree[n+i] = arr[i];
}
// construye el árbol calculando a los padres
for (int i = n - 1; i > 0; --i) {
tree[i] = max(tree[i<<1], tree[i<<1 | 1]);
}
}
// Función para actualizar un nodo de árbol
void updateTreeNode(int index, int value) {
// Establecer el valor en la posición p
tree[index+n] = value;
index = index + n;
// Moverse hacia arriba y actualizar a los padres
for (int i = index; i > 1; i >>= 1){
tree[i>>1] = max(tree[i], tree[i^1]);
}
}
// función para obtener la suma en el intervalo [l, r)
int query(int l, int r) {
int ans = NEUTRAL_MIN;
// bucle para encontrar la suma en el rango
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l&1) {
ans = max(ans, tree[l++]);
}
if (r&1) {
ans = max(ans, tree[--r]);
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
n++;
vector<int> val(n);
for(int i = 1; i < n; ++i) {
cin >> val[i];
}
build(val);
vector<bool> visited(n, false);
int colors = 0;
int last;
for(int i = 1; i < n; ++i) {
if(!visited[i]) {
colors++;
last = val[i];
visited[i] = true;
updateTreeNode(i, -oo);
if(query(i+1, n) <= last) continue;
for(int j = i + 1; j < n; ++j) {
if(!visited[j] && last < val[j]) {
last = val[j];
visited[j] = true;
updateTreeNode(j, -oo);
if(query(j+1, n) <= last) break;
}
}
}
}
cout << colors << endl;
return 0;
} | 1 |
#include<iostream>
using namespace std;
int cnt;
void insertionSort(int* a, int n, int g){
int i, j, v;
for(i = g; i < n; i++){
v = a[i];
j = i - g;
while((j >= 0) && (a[j] > v)){
a[j + g] = a[j];
j = j - g;
cnt++;
};
a[j + g] = v;
}
}
void shellsort(int* a, int n)
{
cnt = 0;
int i, p;
int m;
int G[15];
p = 1;
for(i = 1; i < 20; i++){
p = p * 3;
if(p - 1 > 2 * n) break;
}
if(i > 1) i = i - 1;
m = i;
p = 1;
for(i = 0; i < m; i++){
p = p * 3;
G[m - 1 - i] = (p - 1) / 2;
}
cout << m << endl;
for(i = 0; i < m - 1; i++) cout << G[i] << " ";
cout << G[m - 1] << endl;
for(int i = 0; i < m; i++){
insertionSort(a, n, G[i]);
}
}
int main()
{
int i, A[1000000], n;
cin >> n;
for(i = 0; i < n; i++) cin >> A[i];
shellsort(A, n);
cout << cnt << endl;
for(i = 0; i < n; i++) cout << A[i] << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main() {
using LL = long long;
int N;
cin >> N;
vector<LL> A(N);
for(auto& i: A) cin >> i;
const LL NG = -1e18;
vector<map<int, LL>> memo(N);
function<LL(int,int)> dfs = [&](int i, int n) {
if(n == 0) return 0ll;
if(N <= i) return NG;
if(N < i+2*n-1) return NG;
if(memo[i][n]) return memo[i][n];
return memo[i][n] = max(dfs(i+1, n), A[i]+dfs(i+2, n-1));
};
cout << dfs(0, N/2) << endl;
}
| 0 |
#include <stdio.h>
int main()
{
int n,m,b[1000],a[1000];
int sum[1000]={0};
scanf("%d %d",&n,&m);
for(int i=0;i<=n-1;i++){
scanf("%d",&a[i]);
}
for(int j=0;j<=m-1;j++){
scanf("%d",&b[j]);
}
for(int j=0;j<=m-1;j++){
for(int i=0;i<=n-1;i++){
if(b[j]>=a[i]) {sum[i]=sum[i]+1;break;}
}
}
int max=-1;
for(int k=0;k<=n-1;k++){
if(sum[k]>=max) max=sum[k];
}
for(int i=0;i<=n-1;i++){
if(sum[i]==max) printf("%d\n",i+1);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(int)(b);i++)
#define rep(i,n) FOR(i,0,n)
#define ZERO(a) memset(a,0,sizeof(a))
#define pb push_back
int rank[1020];
int main() {
int n, m;
ZERO(rank);
cin >> n >> m;
vector<int> v;
rep(i,n) {
int cost; scanf("%d",&cost);
v.pb(cost);
}
rep(i,m) {
int c; scanf("%d",&c);
rep(j,n) if(c >= v[j]) {
rank[j+1]++; break;
}
}
int ans = 0, ma = 0;
rep(i,1001) if(ma < rank[i]) {
ma = rank[i];
ans = i;
}
cout << ans << "\n";
return 0;
} | 1 |
#include<bits/stdc++.h>
#define REP(i,n) for(long long i=0;i<n;++i)
#define FOR(i,a,b) for(long long i=a;i<b;++i)
using namespace std;
using point = pair< int,int >;
using ll = long long;
int main(){
int n;
int c;
int graph[11];
while (~scanf("%d", &n)) {
if (!n) break;
fill(graph, graph + 11, 0);
REP(i, n) {
scanf("%d", &c);
graph[c]++;
}
FOR(i, 0, 10) {
if (!graph[i]) printf("-\n");
else {
REP(j, graph[i]) printf("*");
puts("");
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int M = 1e6;
set<int> adj[M];
int nd, indeg[M];
bool vis[M];
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int n;
cin >> n;
map<pair<int, int>, int > mp;
int mat[n][n - 1];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - 1; j++) {
cin >> mat[i][j];
mat[i][j]--;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - 2; j++) {
pair<int, int> p1 = {i, mat[i][j]}, p2 = {i, mat[i][j + 1]};
if (p1.first > p1.second)
swap(p1.first, p1.second);
if (p2.first > p2.second)
swap(p2.first, p2.second);
if (mp.find(p1) == mp.end())
mp[p1] = nd++;
if (mp.find(p2) == mp.end())
mp[p2] = nd++;
if (adj[mp[p1]].find(mp[p2]) == adj[mp[p1]].end()) {
adj[mp[p1]].insert(mp[p2]);
indeg[mp[p2]]++;
}
}
}
queue<pair<int, int> > q;
for (int i = 0; i < nd; i++) {
if (indeg[i] == 0) {
vis[i] = true;
q.push({i, 1});
}
}
int ans = -1;
while (!q.empty()) {
int v = q.front().first, d = q.front().second;
q.pop();
for (auto nbr : adj[v])
indeg[nbr]--;
ans = d;
for (auto nbr : adj[v]) {
if (!vis[nbr] && indeg[nbr] == 0) {
vis[nbr] = true;
q.push({nbr, d + 1});
}
}
}
for (int i = 0; i < n; i++) {
if (!vis[i])
ans = -1;
}
cout << ans;
return 0;
} | 0 |
#include<bits/stdc++.h>
using ll=long long;
using namespace std;
#define rep(i, n) for(ll i=0; i<n; i++)
#define Rep(i, j, n) for(ll i=j; i<n; i++)
#define all(vec) vec.begin(), vec.end()
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 dh[4] = {-1, 0, 0, 1};
int dw[4] = {0, -1, 1, 0};
using P = pair<int, int>;
const double pi = acos(-1.0);
int main(){
string s;
cin>>s;
vector<bool>ch(26);
string ans="abcdefghijklmnopqrstuvwxyz";
rep(i,s.size()){
ch[s[i]-'a']=true;
}
rep(i,26){
if(!ch[i]){cout<<ans[i]<<endl;return 0;}
}
cout<<"None"<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define mod 1000000007
int main(){
fast;
string s;
cin>>s;
int fre[26]={0};
for(int i=0;i<s.length();i++)
fre[s[i]-97]++;
for(int i=0;i<26;i++)
{
if(fre[i]==0)
{
cout<<(char)(i+97);
return 0;
}
}
cout<<"None";
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<pi> vpi;
typedef vector<vi> vii;
typedef map<int, int> mp;
typedef multiset<int> mset;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
typedef vector<int64> vi64;
#define fast ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define form(i,j,k,l) for(int i=j;i<int(k);i+=l)
#define rform(i,j,k,l) for(int i=int(j);i>int(l);i-=l)
#define rep(i, j) for(int i=0;i<int(j);i++)
#define rrep(i, j) for(int i=int(j);i>=0;i--)
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define forc(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define IN(A, B, C) assert( B <= A && A <= C)
#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define INF (int)1e9
#define INF64 (int64)1e18
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
#define F first
#define S second
const double pie = acos(-1.0);
template <typename T>
T Max(T x, T y)
{
return (x > y) ? x : y;
}
template <typename T>
T Min(T x, T y)
{
return (x > y) ? y : x;
}
int gcd(int n1, int n2)
{
if (n2 != 0) return gcd(n2, n1 % n2);
else return n1;
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::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
clock_t time_p = clock();
void rtime() { time_p = clock() - time_p; cerr << "Time Taken : " << (float)1000 * (time_p) / CLOCKS_PER_SEC << "\n";}
int main()
{ fast;
int64 n;
cin >> n;
int64 r = (int64)sqrt((double)n);
for (int64 i = r; i >= 1; i--)
{ if (n % i == 0)
{ int k = n / i;
int l = 0;
while (k > 0)
{ k = k / 10;
l++;
}
cout << l;
return 0;
}
}
} | #include<bits/stdc++.h>
#define fast ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define int long long
#define endl '\n'
using namespace std;
const int N = 2e5 + 77;
int A[N];
int F(int a,int b){
string x = to_string(a);
string y = to_string(b);
return max(x.length(),y.length());
}
int32_t main(){
fast;
int n , ans = 1e12; cin >> n ;
for(int i = 1 ; i*i <= n ; ++i){
if(n%i==0){
int a = i ,b = n/i;
ans = min(ans,F(a,b));
}
}
cout << ans << endl;
return 0;
} | 1 |
#include<iostream>
using namespace std;
int InsertionSort(int* a, int n, int g)
{
int tmp, j, count = 0;
for (int i = g; i < n; i++)
{
tmp = a[i];
for (j = i - g; j >= 0 && a[j] > tmp; j -= g)
{
a[j + g] = a[j];
count++;
}
a[j + g] = tmp;
}
return count;
}
int ShellSort(int* a, int n)
{
int m, g[100],count = 0;
for (m = 1; m * m * m <= n; m++)
continue;
m--;
cout << m << endl;
for (int i = 0; i < m; i++)
{
g[i] = (m - i) * (m - i);
if (i)
cout << " ";
cout << g[i];
}
for (int i = 0; i < m; i++)
count += InsertionSort(a, n, g[i]);
return count;
}
int main()
{
int n, a[1000000], count;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
count = ShellSort(a, n);
cout << endl << count << endl;
for (int i = 0; i < n; i++)
cout << a[i] << endl;
return 0;
}
| #define dbg(...) fprintf(stderr,__VA_ARGS__)
#define dpr(x) cerr<<#x<<": "<<x<<endl;
#define dprc(c) do{cerr<<#c<<":";for(auto&_i:(c)){cerr<<" "<<_i;}cerr<<endl;}while(0)
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
int INF = 1e9+7;
#define all(c) begin(c), end(c)
#define tr(i,c) for(auto i=begin(c);i!=end(c);i++)
#define rtr(i,c) for(auto i=(c).rbegin();i!=(c).rend();i++)
#define rep(i,b) for(auto i=0;i<(b);i++)
#define pb push_back
#define sz(c) int((c).size())
int cnt, m;
vi G;
void insertionSort(vi& A, int n, int g) {
for (int i = g; i < n; i++) {
int v = A[i];
int j = i - g;
while (j >= 0 && A[j] > v) {
A[j+g] = A[j];
j = j - g;
cnt++;
}
A[j+g] = v;
}
}
void shellSort(vi& A, int n) {
cnt = 0;
G = vi(0);
int g = 1;
do {
G.pb(g);
g = g*3 + 1;
} while (g <= n);
reverse(all(G));
m = sz(G);
for (auto& g:G) {
insertionSort(A, n, g);
}
}
void dump(vi& A, const string& sep) {
string sp = "";
for (auto& a:A) {
cout << sp << a;
sp = sep;
}
cout << endl;
}
int main(int argc, char **argv)
{
vi A;
int n;
cin >> n;
A = vi(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
shellSort(A, n);
cout << m << endl;
dump(G, " ");
cout << cnt << endl;
dump(A, "\n");
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <iomanip>
#include <cassert>
#include <random>
#include <tuple>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_V = 10010;
int V;
int cmp[MAX_V]; // components of each vertex
bool used[MAX_V];
vector<int> g[MAX_V], rg[MAX_V], ng[MAX_V], vs;
void add_edge(int from, int to) {
g[from].push_back(to);
rg[to].push_back(from);
}
void dfs(int v) {
used[v] = true;
for (int nv: g[v]) {
if (!used[nv]) dfs(nv);
}
vs.push_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (int nv: rg[v]) {
if (!used[nv]) rdfs(nv, k);
}
}
// return number of components
int scc() {
memset(used, false, sizeof(used));
vs.clear();
for (int v = 0; v < V; v++) {
if (!used[v]) dfs(v);
}
memset(used, false, sizeof(used));
int k = 0;
for (int i = vs.size()-1; i >= 0; i--) {
if (!used[vs[i]]) rdfs(vs[i], k++);
}
return k;
}
void new_graph(int k) {
for (int v = 0; v < V; v++) {
for (int nv: g[v]) {
int x = cmp[v];
int y = cmp[nv];
if (x == y) continue;
ng[x].push_back(y);
}
}
}
int main() {
int e; cin >> V >> e;
rep(i, e) {
int s, t; cin >> s >> t;
add_edge(s, t);
}
scc();
int q; cin >> q;
rep(i, q) {
int u, v; cin >> u >> v;
cout << (cmp[u] == cmp[v] ? 1 : 0) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int N;
int dubling[22][100005];
int X[100005];
int L;
int main()
{
cin >> N;
for ( int i = 0; i < N; i++ ) cin >> X[i];
cin >> L;
for ( int i = 0; i < N; i++ ) {
dubling[0][i] = upper_bound(X, X + N, X[i] + L) - X - 1;
//cout << dubling[0][i] << " ";
}
//cout << endl;
for ( int p = 1; p < 22; p++ ) {
for ( int i = 0; i < N; i++ ) {
dubling[p][i] = dubling[p - 1][dubling[p - 1][i]];
//cout << p << " " << i << " " << dubling[p][i] << endl;
}
}
int Q;
cin >> Q;
while ( Q-- ) {
int a, b;
cin >> a >> b; --a, --b;
if ( a > b ) swap(a, b);
int bit = 0;
int node = a;
for ( int p = 21; p >= 0; p-- ) {
if ( dubling[p][node] < b ) {
node = dubling[p][node];
bit |= (1 << p);
}
}
cout << bit + 1 << endl;
}
return ( 0 );
}
| 0 |
#include <bits/stdc++.h>
#include <stdio.h>
#include <math.h>
using namespace std;
using vi = vector<int>;
using vll = vector<long long int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vvll = vector<vector<long long int>>;
using ll = long long int;
int main(){
ll N; string A, B, C; cin >> N >> A >> B >> C;
ll c = 0;
for(int i=0; i<N; i++){
if(A[i] == B[i]&&B[i] ==C[i]){}
else if(A[i] == B[i]&&B[i] !=C[i]){c++;}
else if(A[i] != B[i]&&B[i] ==C[i]){c++;}
else if(A[i] == C[i]&&B[i] !=C[i]){c++;}
else{c += 2;}
}
cout << c;
} | #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include<bits/stdc++.h>
using namespace std;
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define int long long
#define endl "\n"
#define all(x) (x).begin(),(x).end()
const int MOD = 1e9+7;
const int mxN = 2e5+3;
void solve(){
int n, x, t;
cin >> n >> x >> t;
int r = n/x;
if(n % x != 0)r++;
int ans = r * t;
cout << ans << endl;
}
int32_t main(){
IO;
int nT = 1;
//cin >> nT;
for(int i = 1; i <= nT; ++i)
solve();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int64_t A, B, K;
cin >> A >> B >> K;
for(int i=0; i<K; i++){
if(i%2==0){
A=2*(A/2);
B+=A/2;
A/=2;
}
else{
B=2*(B/2);
A+=B/2;
B/=2;
}
}
cout << A << " " << B << endl;
} | #include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
int main()
{
double x1,x2,y1,y2,p;
cin>>x1>>y1>>x2>>y2;
x1=x2-x1;
y1=y2-y1;
x1=sqrt(x1*x1+y1*y1);
cout<<setprecision(10)<<x1<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, n) for(int i = 0; i < n; i++)
#define REP(i, a, b) for(int i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define debug(...) cerr<<__LINE__<<" ["<<#__VA_ARGS__<<"]:",debug_out(__VA_ARGS__)
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec)
{ for (auto v : vec) os << v << ' '; os << '\n'; return os; }
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa)
{ os << '(' << pa.first << ',' << pa.second << ')'; return os; }
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T)
{ cerr << " " << H; debug_out(T...); }
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 = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
void solve() {
int n;
cin >> n;
vector<int> A(n);
vector<pii> X;
rep(i, n) {
int a;
cin >> a;
X.push_back({a, i});
}
auto compare = [](pii a, pii b) {
if (a.fi > b.fi) return true;
else if (a.fi == b.fi) return a.se < b.se;
else return false;
};
sort(all(X), compare);
vector<int> dp(n + 1, INF);
rep(i, (int)X.size()) {
int idx = X[i].se;
*lower_bound(all(dp), idx) = idx;
}
int ans = 0;
chmax(ans, (int)(lower_bound(all(dp), INF) - dp.begin()));
cout << ans << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <typename T> void read(T &t) {
t=0; char ch=getchar(); int f=1;
while (ch<'0'||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
do { (t*=10)+=ch-'0'; ch=getchar(); } while ('0'<=ch&&ch<='9'); t*=f;
}
int n,m,flag;
char s[1010][1010],ans[1010][1010];
void solve7() {
m=7;
for (int i=1;i<=m;i++)
for (int j=1;j<=m;j++) s[i][j]='.';
for (int i=1;i<m;i+=3)
for (int j=1;j<m;j+=3) {
s[i][j+1]=s[i][j+2]='a';
s[i+1][j]=s[i+2][j]='b';
}
char ch='c';
for (int i=1;i<m;i+=2) {
s[i][m]=ch,s[i+1][m]=ch;
if (ch=='c') ch='d'; else ch='c';
}
ch='c';
for (int i=1;i<m;i+=2) {
s[m][i]=ch,s[m][i+1]=ch;
if (ch=='c') ch='d'; else ch='c';
}
}
void solve6() {
m=6;
for (int i=1;i<=m;i++)
for (int j=1;j<=m;j++) s[i][j]='.';
s[1][1]=s[1][2]='a';
s[1][5]=s[1][6]='b';
s[2][4]=s[2][5]='c';
s[4][2]=s[4][3]='d';
s[5][1]=s[5][2]='e';
s[6][5]=s[6][6]='f';
s[2][1]=s[3][1]='g';
s[1][3]=s[2][3]='h';
s[3][6]=s[4][6]='i';
s[3][4]=s[4][4]='j';
s[5][3]=s[6][3]='k';
s[5][4]=s[6][4]='l';
}
void solve5() {
m=5;
for (int i=1;i<=m;i++)
for (int j=1;j<=m;j++) s[i][j]='.';
for (int i=1;i<=m;i+=5)
for (int j=1;j<=m;j+=5) {
s[i][j]=s[i][j+1]='a';
s[i][j+2]=s[i][j+3]='b';
s[i][j+4]=s[i+1][j+4]='c';
s[i+1][j]=s[i+2][j]='d';
s[i+1][j+2]=s[i+1][j+3]='e';
s[i+2][j+1]=s[i+3][j+1]='f';
s[i+2][j+4]=s[i+3][j+4]='g';
s[i+3][j]=s[i+4][j]='i';
s[i+4][j+1]=s[i+4][j+2]='j';
s[i+4][j+3]=s[i+4][j+4]='h';
}
}
void solve4() {
m=4;
for (int i=1;i<=m;i++)
for (int j=1;j<=m;j++) s[i][j]='.';
s[1][1]=s[1][2]='a';
s[1][3]=s[2][3]='b';
s[1][4]=s[2][4]='c';
s[2][1]=s[2][2]='d';
s[3][1]=s[4][1]='e';
s[3][2]=s[4][2]='f';
s[3][3]=s[3][4]='g';
s[4][3]=s[4][4]='h';
}
int main() {
//freopen("1.txt","r",stdin);
read(n);
if (n==2) { printf("-1\n"); return 0; }
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++) ans[i][j]='.';
if (n%3==0) {
for (int i=1;i<=n;i+=3)
for (int j=1;j<=n;j+=3) {
ans[i][j+1]=ans[i][j+2]='a';
ans[i+1][j]=ans[i+2][j]='b';
}
} else {
int t=n/4-1;
solve4();
for (int i=1;i<=t*4;i+=4) {
for (int x=1;x<=4;x++)
for (int y=1;y<=4;y++)
ans[i+x-1][i+y-1]=s[x][y];
}
t=n-t*4;
if (t==4) solve4();
else if (t==5) solve5();
else if (t==6) solve6();
else solve7();
int i=1+(n/4-1)*4;
for (int x=1;x<=t;x++)
for (int y=1;y<=t;y++)
ans[i+x-1][i+y-1]=s[x][y];
}
for (int i=1;i<=n;i++)
printf("%s\n",ans[i]+1);
return 0;
}
/*
REMEMBER:
1. Think TWICE, Code ONCE!
Are there any counterexamples to your algo?
2. Be careful about the BOUNDARIES!
N=1? P=1? Something about 0?
3. Do not make STUPID MISTAKES!
Array size? Integer overflow? Time complexity? Memory usage? Precision error?
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5, mod = 1e9 + 7;
int main()
{
//ios::sync_with_stdio(false);cin.tie(nullptr);ios_base::sync_with_stdio(false);
int n, m, c = 0, x;
map<int, ll> mp;
mp[0]++;
cin >> n >> m;
while (n--)
cin >> x,
c += x,
c %= m,
mp[c]++;
ll ans = 0;
for (auto it: mp)
ans += it.second * (it.second - 1) / 2;
cout << ans;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <cstring>
#include <math.h>
#include <bitset>
#include <queue>
#include <set>
#include <iomanip>
#include <assert.h>
#include <cstdio>
// #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr long long int infll = 1001001001001001LL;
constexpr int INF = 1000000007;
constexpr int inf = 1000000007;
const int mod = 1000000007;
inline bool chmin(ll &a, ll b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
inline bool chmax(ll &a, ll b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
template <typename T>
T seinomi(T a)
{
if (a > 0)
{
return a;
}
else
{
return 0;
}
}
//桁数取得
template <typename T>
T ketasuu(T num)
{
return std::to_string(num).length();
}
//整数乗
ll llpow(ll a, ll n)
{
if (n == 0)
{
return 1;
}
else
{
ll rep = a;
for (ll i = 1; i < n; i++)
{
rep *= a;
}
return rep;
}
}
template <class ForwardIt, class T>
void iota(ForwardIt first, ForwardIt last, T value)
{
while (first != last)
{
*first++ = value;
++value;
}
}
template <typename T>
T amarinasi(T a, T b)
{
if (a % b == 0)
{
return a / b;
}
else if (a % b > 0)
{
return a / b + 1;
}
else
{
return a / b - 1;
}
}
//小数点以下10桁テンプレート（main関数内の最初に貼付け）
//std::cout << std::fixed << std::setprecision(10);
//----------------------------------------------------------------
//組み合わせ nCr
vector<vector<ll>> nCr_v(5010, vector<ll>());
bool nCr_maekeisan = false;
void nCr_Calculater()
{
for (int i = 0; i < 5010; i++)
{
nCr_v[i][0] = 1;
nCr_v[i][i] = 1;
}
for (int k = 1; k < 5010; k++)
{
for (int j = 1; j < k; j++)
{
nCr_v[k][j] = (nCr_v[k - 1][j - 1] + nCr_v[k - 1][j]);
}
}
}
ll nCr(ll n, ll r)
{
if (n > 5010 || r > 5010)
{
cout << "ERROR! over range" << endl;
return 0;
}
if (n < 0 || r < 0)
{
return 0;
}
else
{
if (nCr_maekeisan == false)
{
for (ll i = 0; i < 5010; i++)
{
nCr_v[i].resize(5010);
}
nCr_Calculater();
nCr_maekeisan = true;
}
return nCr_v[n][r];
}
}
int main()
{
ll n, m;
cin >> n >> m;
ll a[n];
for (ll i = 0; i < n; i++)
{
cin >> a[i];
}
map<ll, ll> rensou;
ll ruiseki[n + 1];
ruiseki[0] = a[0] % m;
rensou[ruiseki[0]]++;
for (ll i = 0; i < n; i++)
{
ruiseki[i + 1] = ruiseki[i] + a[i];
ruiseki[i + 1] %= m;
rensou[ruiseki[i + 1]]++;
}
ll ans = 0;
for (auto f : rensou)
{
ans += ((f.second) * (f.second - 1)) / 2;
}
cout << ans << endl;
}
| 1 |
#include <cstdio>
#include <cstring>
#define maxn 200010
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
inline long long min(long long a, long long b) {return a < b ? a : b;}
inline long long abs(long long a) {return a > 0 ? a : -a;}
int n, k, x, y;
int q, last;
long long V[maxn << 2][3], cov[maxn << 2];
void pushdown(int rt) {
int lc = rt << 1, rc = rt << 1 | 1;
long long &tmp = cov[rt];
V[lc][0] += tmp;
V[lc][1] += tmp;
V[lc][2] += tmp;
cov[lc] += tmp;
V[rc][0] += tmp;
V[rc][1] += tmp;
V[rc][2] += tmp;
cov[rc] += tmp;
tmp = 0;
}
void update(int rt) {
int lc = rt << 1, rc = rt << 1 | 1;
V[rt][0] = min(V[lc][0], V[rc][0]);
V[rt][1] = min(V[lc][1], V[rc][1]);
V[rt][2] = min(V[lc][2], V[rc][2]);
}
void add(int rt, int l, int r, int p, long long num) {
if (l == r) {
V[rt][0] = num;
V[rt][1] = num + l;
V[rt][2] = num - l;
return ;
}
if (cov[rt]) pushdown(rt);
int mid = l + r >> 1;
if (p <= mid) add(rt << 1, l, mid, p, num);
else add(rt << 1 | 1, mid + 1, r, p, num);
update(rt);
}
void add(long long num, int rt = 1) {
V[rt][0] += num;
V[rt][1] += num;
V[rt][2] += num;
cov[rt] += num;
}
long long ask(int rt, int l, int r, int L, int R, int op) {
if (L <= l && R >= r) return V[rt][op];
pushdown(rt);
int mid = l + r >> 1;
long long ans = inf;
if (L <= mid) ans = ask(rt << 1, l, mid, L, R, op);
if (R > mid) ans = min(ans, ask(rt << 1 | 1, mid + 1, r, L, R, op));
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &k, &x, &y);
scanf("%d", &q);
memset(V, 0x3f, sizeof V);
add(1, 1, n, x, abs(y - q));
add(1, 1, n, y, abs(x - q));
while (--k) {
last = q; scanf("%d", &q);
long long t0 = ask(1, 1, n, last, last, 0) + abs(q - last);
long long t1 = ask(1, 1, n, q, n, 1) - q;
long long t2 = ask(1, 1, n, 1, q, 2) + q;
long long ans = min(t0, min(t1, t2));
add(abs(q - last));
add(1, 1, n, last, ans);
}
printf("%lld\n", V[1][0]);
return 0;
} | #include<bits/stdc++.h>
#define ll long long
using namespace std;
int dp[85][85][40000]={};
int grid[85][85];
int main(){
int h,w;
cin>>h>>w;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cin>>grid[i][j];
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
int k;
cin>>k;
grid[i][j]=abs(grid[i][j]-k);
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
int x=grid[i][j];
if(i==0&&j==0){
dp[i][j][20000+x]=1;
dp[i][j][20000-x]=1;
continue;
}
if(i==0){
for(int k=1000;k<39000;k++){
dp[i][j][k]+=max(dp[i][j-1][k+x],0);
dp[i][j][k]+=max(dp[i][j-1][k-x],0);
dp[i][j][k]=min(1,dp[i][j][k]);
}
continue;
}
if(j==0){
for(int k=1000;k<39000;k++){
dp[i][j][k]+=max(dp[i-1][j][k+x],0);
dp[i][j][k]+=max(dp[i-1][j][k-x],0);
dp[i][j][k]=min(1,dp[i][j][k]);
}
continue;
}
for(int k=1000;k<39000;k++){
dp[i][j][k]+=max(dp[i][j-1][k+x],0);
dp[i][j][k]+=max(dp[i][j-1][k-x],0);
dp[i][j][k]=min(1,dp[i][j][k]);
}
for(int k=1000;k<39000;k++){
dp[i][j][k]+=max(dp[i-1][j][k+x],0);
dp[i][j][k]+=max(dp[i-1][j][k-x],0);
dp[i][j][k]=min(1,dp[i][j][k]);
}
}
}
int ans=50000;
for(int i=0;i<40000;i++){
if(dp[h-1][w-1][i]>0){
ans=min(ans,abs(i-20000));
}
}
cout<<ans<<endl;
} | 0 |
/**
* author: souzai32
* created: 02.08.2020 15:41:51
**/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
long long int x,y;
cin >> x >> y;
long long int count=0;
while(1){
if(x==y) break;
else if(x<y){
if(abs(x)<abs(y)) {
if(x>=0){
count+=y-x;
x+=y-x;
}
else{
count++;
x*=-1;
}
}
else if(abs(x)==abs(y)){
count++;
x*=-1;
}
else{
if(y>=0){
count+=abs(x)-y;
x+=abs(x)-y;
}
else{
count+=y-x;
x+=y-x;
}
}
}
else if(y<x){
if(abs(x)>abs(y) || x<0){
count++;
x*=-1;
}
else if(abs(x)==abs(y)){
count++;
x*=-1;
}
else{
count+=abs(y)-x;
x+=abs(y)-x;
}
}
//cout << x << ' ' << y << endl;
}
cout << count << endl;
return 0;
} | #include <cstdio>
const long long mod=998244353ll;
const int MSIZE=4000000;
void ad(long long &a,long long b){a+=b;a%=mod;}
void mn(long long &a,long long b){a+=mod-b;a%=mod;}
void ml(long long &a,long long b){a*=b;a%=mod;}
long long sq(long long a){return a*a%mod;}
long long pw(long long a,long long n)
{
return n==0?1ll:sq(pw(a,n/2))*(n%2==1?a:1ll)%mod;
}
long long iv(long long a){return pw(a,mod-2);}
long long inv[MSIZE],F[MSIZE],iF[MSIZE];
void prev(int N)
{
inv[0]=0;
inv[1]=1;
for(int i=2;i<N;i++){
inv[i]=(mod-mod/i)*inv[mod%i]%mod;
}
F[0]=iF[0]=1;
for(int i=1;i<N;i++){
F[i]=F[i-1]*i%mod;
iF[i]=iF[i-1]*inv[i]%mod;
}
}
long long Ch(int i,int j)
{
return i<0||j<0||i<j?0:F[i]*iF[j]%mod*iF[i-j]%mod;
}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
prev(n+3*m);
long long ans=Ch(3*m+n-1,n-1);
mn(ans,n*Ch(m-1+n-1,n-1)%mod);
for(int i=m+1;i<=3*m&&i<=n;i++){
if((3*m-i)%2==0){
mn(ans,Ch(n,i)*Ch((3*m-i)/2+n-1,n-1)%mod);
}
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+10;
ll n,S;
ll a[N],p[N],tag[N];
ll ans;
int main(){
cin>>n>>S;
for (int i=1;i<=n;i++)
scanf("%lld%lld",&a[i],&p[i]);
int l=1,r=n;
while (a[l]<=S&&S<=a[r]){
if (p[l]>=p[r]){
if (!tag[l])ans+=a[r]-a[l],tag[l]=1;
p[l]+=p[r];
r--;
}
else {
if (!tag[r])ans+=a[r]-a[l],tag[r]=1;
p[r]+=p[l];
l++;
}
}
ans+=max(abs(S-a[l]),abs(S-a[r]));
cout<<ans<<endl;
} | //
// Created by Mahmoud Rashad on 11/27/19.
//
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<pair<ii, ii>> vii;
const int MAXN = 1003;
int vis[MAXN];
int mark[MAXN], checkID;
vector<int> adjList[MAXN];
vector<int> inProgress;
bool ret;
bool check(int x) {
// cout << x << endl;
++checkID;
mark[x] = checkID;
inProgress.push_back(x);
for (int i = (int)inProgress.size() - 2; inProgress[i] != x; --i)
mark[inProgress[i]] = checkID;
int i;
for (i = (int)inProgress.size() - 2; inProgress[i] != x; --i) {
int u = inProgress[i];
for (int v : adjList[u]) {
if (mark[v] == checkID && v != inProgress[i + 1]) {
inProgress.pop_back();
return false;
}
}
}
for (int v : adjList[x]) {
if (mark[v] == checkID && v != inProgress[i + 1]) {
inProgress.pop_back();
return false;
}
}
return true;
}
void dfs(int u) {
vis[u] = 1;
inProgress.push_back(u);
for (int v : adjList[u]) {
if (vis[v] == 1) {
// cout << v << endl;
ret = check(v);
if (ret)
return;
} else if (vis[v] == 0) {
dfs(v);
if (ret)
return;
}
}
inProgress.pop_back();
vis[u] = 2;
}
int main() {
#ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.out", "w", stdout);
#endif
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0), cout.precision(10), cout << fixed;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
adjList[u].push_back(v);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
dfs(i);
if (ret) {
vector<int> ans;
for (int i = (int)inProgress.size() - 2; inProgress[i] != inProgress.back(); --i)
ans.push_back(inProgress[i]);
ans.push_back(inProgress.back());
cout << ans.size() << '\n';
reverse(ans.begin(), ans.end());
for (int x : ans)
cout << x << '\n';
return 0;
}
}
}
cout << -1 << '\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using G = vector<vector<int>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll MOD = 1000000007;
ll GCD(ll x, ll y){
return y ? GCD(y, x%y) : x;
}
int main() {
int n, m, x, y; cin >> n >> m >> x >> y;
int x_max = x;
int y_min = y;
for(int i=0;i<n;i++){
int a; cin >> a;
x_max = max(x_max, a);
}
for(int i=0;i<m;i++){
int b; cin >> b;
y_min = min(y_min, b);
}
if(x_max<y_min){
cout << "No War" << endl;
return 0;
}
cout << "War" << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> xs(n + 1), ys(m + 1);
cin >> xs[0] >> ys[0];
for (int i = 1; i <= n; ++i)
cin >> xs[i];
for (int i = 1; i <= m; ++i)
cin >> ys[i];
if (*max_element(xs.begin(), xs.end()) < *min_element(ys.begin(), ys.end()))
cout << "No War" << endl;
else
cout << "War" << endl;
}
| 1 |
#include<iostream>
int main(){
int x;
std::cin >> x;
std::cout << x*x*x << "\n";
return 0;
} | #include<iostream>
using namespace std;
int64_t cubic(const int64_t x) {
return x*x*x;
}
void print(const int64_t x) {
cout << x << endl;
}
int main() {
int64_t x;
cin >> x;
//print x^3
print(cubic(x));
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define vi vector<int>
#define vvi vector<vector<int>>
#define pi pair<int, int>
#define ALL(a) (a).begin(), (a).end()
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end()) //sortしてからつかうこと
constexpr ll MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
signed main() {
cin >> N >> M;
vi a(N);
cin >> a;
sort(a.rbegin(), a.rend());
REP(i, M)
ans += a[i];
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
vector<int> v(n);
for(int i = 0;i<n;i++)
{
cin>>v[i];
}
int minsofar = INT_MAX;
int count = 0;
for(int i = 0;i<n;i++)
{
minsofar = min(minsofar,v[i]);
if(v[i] <= minsofar)
{
count++;
}
}
cout<<count;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,p,q,r;
cin >> a >> b >> c;
p = a+b;
q = a+c;
r = b+c;
if(p>=q){
if(q >= r){
cout << r;
}else{
cout << q;
}
}else{
if(p >= r){
cout << r;
}else{
cout << p;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main(){
vector<int> v(3);
for(int &e : v) cin >> e;
sort(v.begin(), v.end());
cout << v[0] + v[1];
}
| 1 |
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define rep(i, s, t) for(i = s; i <= t; ++i)
#define dep(i, s, t) for(i = s; i >= t; --i)
using namespace std;
const double Pi = acos(-1.);
const int N = 110;
int n;
struct D{double x, y, f;} d[N], e[N];
double ans[N];
bool cmp(D a, D b) {return a.f < b.f;}
int main() {
int i, j, m; D key;
scanf("%d", &n);
rep(i, 1, n) scanf("%lf%lf", &d[i].x, &d[i].y);
rep(i, 1, n) {
key = d[i];
m = 0;
rep(j, 1, n)
if(i != j) {e[++m] = d[j]; e[m].f = atan2(e[m].y-key.y, e[m].x-key.x);}
sort(e+1, e+m+1, cmp);
rep(j, 1, m-1)
if(e[j+1].f - e[j].f > Pi) ans[i] = (e[j+1].f - e[j].f - Pi) / Pi / 2.;
if(e[1].f + Pi + Pi - e[m].f > Pi) ans[i] = (e[1].f + Pi - e[m].f) / Pi / 2.;
printf("%.7lf\n", ans[i]);
}
return 0;
} | #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#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() {
int N;
cin>>N;
vector<pair<int, int> > red(N), blue(N);
int a, b;
rep(i, N){
cin>>a>>b;
red[i] = mp(a, b);
}
rep(i, N){
cin>>a>>b;
blue[i] = mp(a, b);
}
sort(red.begin(), red.end(), greater<pair<int, int> >());
map<int, int> amap;
int index;
int tmp;
int ans = 0;
for(int i=0;i<N;++i){
index = -1;
tmp = -1;
for(int j=0;j<N;++j){
if((red[i].fi<blue[j].fi) && (red[i].se<blue[j].se)){
if(((index==-1) || (tmp > blue[j].se)) && (amap[j]==0)){
index = j;
tmp = blue[j].se;
}
}
}
if(index != -1){
amap[index]++;
ans++;
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
#ifdef LOCAL
#include "/media/brayand/7801-B00D/debugger.h"
#else
template<typename... Args>
void db(Args... args){}
#endif
const int MOD = 1e9+7;
const int BAS = 331;
string A[30];
string rA[30];
string B[30];
const int MAXN = 2e5+100;
int mp[MAXN];
int val[MAXN];
int P[MAXN];
int32_t main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
P[0] = 1;
for(int i = 1 ; i < MAXN ; i++)P[i] = P[i-1]*BAS%MOD;
int N;
cin >> N;
for(int i = 0 ; i < N ; i++)
{
int n;
cin >> n;
for(int j = 0 ; j < 30 ; j++)
{
if(n&(1<<j))A[j] += "1", rA[j] += "0";
else A[j] += "0", rA[j] += "1";
}
}
for(int i = 0 ; i < N ; i++)
{
int n;
cin >> n;
for(int j = 0 ; j < 30 ; j++)
{
if(n&(1<<j))B[j] += "1";
else B[j] += "0";
}
}
for(int i = 0 ; i < 30 ; i++)
{
A[i] = A[i]+A[i];
rA[i] = rA[i]+rA[i];
}
vector<pair<int,int>> res[30];
for(int i = 0 ; i < 30 ; i++)
{
int ha1[A[i].size()+1];
int ha2[rA[i].size()+1];
int hhh = 0;
ha1[0] = 1;
ha2[0] = 1;
for(int x = 0 ; x < A[i].size() ; x++)
{
ha1[x+1] = (ha1[x]*BAS+A[i][x])%MOD;
}
for(int x = 0 ; x < rA[i].size() ; x++)
{
ha2[x+1] = (ha2[x]*BAS+rA[i][x])%MOD;
}
for(int x = 0 ; x < B[i].size() ; x++)
{
hhh = (hhh*BAS+B[i][x])%MOD;
}
for(int x = 0 ; x < N ; x++)
{
if((ha1[x+N]+MOD-ha1[x]*P[N]%MOD)%MOD == hhh)
{
res[i].push_back({x,0});
}
}
for(int x = 0 ; x < N ; x++)
{
if((ha2[x+N]+MOD-ha2[x]*P[N]%MOD)%MOD == hhh)
{
res[i].push_back({x,1});
}
}
}
for(int i = 0 ; i < 30 ; i++)
{
for(auto x : res[i])
{
mp[x.first]++;
val[x.first] += (x.second)*(1ll<<i);
}
}
for(int i = 0 ; i < N ; i++)
{
if(mp[i] == 30)
{
cout << i << " " << val[i] << '\n';
}
}
return 0;
} | #define _USE_MATH_DEFINES
#include <array>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <stack>
#include <list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <complex>
#include <cmath>
#include <numeric>
#include <bitset>
#include <functional>
#include <random>
#include <ctime>
using namespace std;
#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...);
}
typedef long long int64;
typedef pair<int, int> ii;
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
mt19937 mrand(random_device{}());
int rnd(int x) { return mrand() % x; }
void solve(const vector<int>& A, const vector<int>& B, vector<int>& mask, int bit) {
int n = A.size() - 1, m = B.size();
vector<int> f(m);
f[0] = 0;
int k = 0;
for (int i = 1; i < m; ++i) {
for (; k > 0 && B[k] != B[i]; k = f[k - 1]);
if (B[k] == B[i]) k++;
f[i] = k;
}
k = 0;
for (int i = 0; i < n; ++i) {
for (; k > 0 && B[k] != A[i]; k = f[k - 1]);
if (B[k] == A[i]) k++;
if (k == m) {
mask[i - m + 1] |= bit;
k = f[k - 1];
}
}
}
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i]);
}
vector<int> A(2 * n), B(n), mask(n);
for (int k = 0; k < 30; ++k) {
for (int i = 0; i < n; ++i) {
A[i + n] = A[i] = (a[i] >> k) & 1;
}
for (int i = 0; i < n; ++i) B[i] = (b[i] >> k) & 1;
solve(A, B, mask, 1 << k);
for (int i = 0; i < n * 2; ++i) A[i] = 1 - A[i];
solve(A, B, mask, 1 << k);
}
for (int i = 0; i < n; ++i) {
if (mask[i] != (1 << 30) - 1) continue;
printf("%d %d\n", i, a[i] ^ b[0]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
#define vi vector<int>
#define e "\n"
#define MaRiaMa { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
#define fix(n) cout << fixed << setprecision(n);
using namespace std;
int main()
{
MaRiaMa;
double r, g,re;
cin >> r >> g;
re = 2 * g - r;
cout<<re;
} | #include <iostream>
#include<cmath>
#include <vector>
#include <map>
#include <iomanip>
#include <algorithm>
#include <sstream>
#include <string>
#include <math.h>
#include <set>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
double a, b;
cin >> a >> b;
cout << b - a + b;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#define rep(i, n) for(i = 0; i < n; i++)
using namespace std;
struct Value {
int depth, cost;
Value() { }
Value(int depth, int cost) {
this->depth = depth;
this->cost = cost;
}
};
int n, k;
int a[100000];
vector<int> et[100000];
Value dfs(int p, int v) {
Value ret(0, 0);
for (int i = 0; i < et[v].size(); i++) {
int nv = et[v][i];
if (nv == p) continue;
Value res = dfs(v, nv);
ret.depth = max(ret.depth, res.depth + 1);
ret.cost += res.cost;
}
if (ret.depth == k - 1 && p != 0) {
ret.depth = -1;
ret.cost++;
}
return ret;
}
int main() {
int i;
cin >> n >> k;
rep(i, n) {
cin >> a[i]; a[i]--;
if (i != 0) {
et[a[i]].push_back(i);
}
}
int ans = dfs(0, 0).cost;
if (a[0] != 0) ans++;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
template<class T> T gcd(const T& a,const T& b){ return b==0?a:gcd(b,a%b); }
int main(){
int n,k; scanf("%d%d",&n,&k);
vector<int> a(n);
rep(i,n) scanf("%d",&a[i]);
int g=a[0];
rep(i,n-1) g=gcd(g,a[i+1]);
puts(k%g==0&&k<=*max_element(a.begin(),a.end())?"POSSIBLE":"IMPOSSIBLE");
return 0;
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str;
cin >> str;
int number_of_instruction;
cin >> number_of_instruction;
for (int i = 0; i < number_of_instruction; ++i)
{
string instruction;
int param1, param2;
string temp_str = "";
string replace_str = "";
cin >> instruction >> param1 >> param2;
if (instruction == "print")
{
for (int i = param1; i <= param2 ; ++i)
{
temp_str += str[i];
}
cout << temp_str << endl;
}
if(instruction == "reverse")
{
for (int i = 0; i < param1; ++i)
{
temp_str += str[i];
}
for (int i = param2; i >= param1; --i)
{
temp_str += str[i];
}
for (int i = param2+1; i < str.size(); ++i)
{
temp_str += str[i];
}
str = temp_str;
}
if(instruction == "replace")
{
string replace_str;
cin >> replace_str;
str.replace(param1, param2 - param1 + 1, replace_str);
}
}
} | #include <bits/stdc++.h>
int main() {
char str[1024];
char ope[256];
char obj[1024];
int q;
int a, b;
char temp;
scanf("%s", str);
scanf("%d", &q);
for(int i = 0; i < q; ++i) {
scanf("%s", ope);
if( strcmp("replace", ope) == 0 ) {
scanf("%d %d", &a, &b);
scanf("%s", obj);
for(int j = a; j <= b; ++j) {
str[j] = obj[j-a];
}
}
else if( strcmp("reverse", ope) == 0 ) {
scanf("%d %d", &a, &b);
for(int j = a; j <= (a+b)/2; ++j) {
temp = str[j]; str[j] = str[a+b-j]; str[a+b-j] = temp;
}
}
else if( strcmp("print", ope) == 0 ) {
scanf("%d %d", &a, &b);
for(int j = a; j <= b; ++j) {
printf("%c", str[j]);
}
printf("\n");
}
else {
printf("nya------\n");
}
}
return 0;
} | 1 |
#include <vector>
#include <cstdio>
#include <algorithm>
using namespace std;
main(){
int a,b,c,n,x,y,z,w,i;
for(;scanf("%d%d%d%d",&a,&b,&c,&n)>3;){
vector<int>A(a,2);
vector<int>B(b,2);
vector<int>C(c,2);
vector<tuple<int,int,int> >v;
for(i=0;i<n;i++){
scanf("%d%d%d%d",&x,&y,&z,&w);
if(w)A[x-1]=B[y-1-a]=C[z-1-a-b]=1;
else v.push_back(make_tuple(x-1,y-1-a,z-1-a-b));
}
for(i=0;i<v.size();i++){
if(A[get<0>(v[i])]==1&&B[get<1>(v[i])]==1)C[get<2>(v[i])]=0;
if(B[get<1>(v[i])]==1&&C[get<2>(v[i])]==1)A[get<0>(v[i])]=0;
if(C[get<2>(v[i])]==1&&A[get<0>(v[i])]==1)B[get<1>(v[i])]=0;
}
for(i=0;i<A.size();i++)printf("%d\n",A[i]);
for(i=0;i<B.size();i++)printf("%d\n",B[i]);
for(i=0;i<C.size();i++)printf("%d\n",C[i]);
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for (int i = (a); i < (int)(b); ++i)
#define endl "\n"
typedef long long ll;
const double pi=3.14159265358979323846;
int ctoi(const char c) {
if ('0' <= c && c <= '9') return (c - '0');
return -1;
}
vector<int> input(int n) {
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
return vec;
}
void output(vector<int> vec) {
for (int i = 0; i < int(vec.size()); i++) {
cout << vec[i] << " ";
}
return;
}
vector<vector<int>> input(int n, int m) {
vector<vector<int>> table(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> table. at(i).at(j);
}
}
return table;
}
void output(vector<vector<int>> table) {
for (int i = 0; i < int(table.size()); i++) {
for (int j = 0; j < int(table.at(0).size()); j++) {
cout << table.at(i).at(j) << " ";
}
cout << endl;
}
}
long long perm(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long perm = 1;
for (int i = n; i > n - r; i--) {
perm *= i;
}
return perm;
}
long long comb(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long comb = perm(n,r);
for (int i = r; i > 0; i--) {
comb /= i;
}
return comb;
}
long long homo(int n, int r) {
return comb(n + r - 1, n - 1);
}
long long fact(int n) {
long long fact = 1;
for (int i = n; i > 0; i--) {
fact *= i;
}
return fact;
}
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);
}
bool isprime(int n){
if (n < 2) return false;
else if (n == 2) return true;
else if (n % 2 == 0) return false;
for (int i = 3; i <= sqrt(n); i += 2){
if (n % i == 0){
return false;
}
}
return true;
}
vector<long long> divisors(long long N) {
vector<long long> res;
for (long long i = 1; i * i <= N; ++i) {
if (N % i == 0) {
res.push_back(i);
// 重複しないならば i の相方である N/i も push
if (N/i != i) res.push_back(N/i);
}
}
// 小さい順に並び替える
sort(res.begin(), res.end());
return res;
/*long long N;
cin >> N;
vector<long long> res = divisors(N);
for (int i = 0; i < res.size(); ++i) {
cout << res[i] << " ";
}
cout << endl;*/
}
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
void Yes(bool f) {
if (f) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
void YES(bool f) {
if (f) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
int main() {
int n,cnt=0;
cin >> n;
string a,b,c;
cin >> a >> b >> c;
rep(i,0,n){
if(a[i]==b[i]&&b[i]==c[i]){
continue;
}else if(a[i]!=b[i]&&b[i]!=c[i]&&c[i]!=a[i]){
cnt+=2;
}else{
cnt++;
}
}
cout << cnt << endl;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
using namespace std;
int main(){
ll l,r;cin>>l>>r;
vector<int> vec;
int ans=2020;
for(int i=l;i<=min(r,l+2040)-1;i++){
for(int j=i+1;j<=min(r,l+2040);j++){
ans=min(ans,((i%2019)*(j%2019))%2019);
}
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const int mod=1e9+7;
const int N=1e6+10;
void read(int &a)
{
a=0;int d=1;char ch;
while(ch=getchar(),ch>'9'||ch<'0') if(ch=='-') d=-1;
a=ch^48;
while(ch=getchar(),ch>='0'&&ch<='9') a=(a<<3)+(a<<1)+(ch^48);
a*=d;
}
void read(ll &a)
{
a=0;int d=1;char ch;
while(ch=getchar(),ch>'9'||ch<'0') if(ch=='-') d=-1;
a=ch^48;
while(ch=getchar(),ch>='0'&&ch<='9') a=(a<<3)+(a<<1)+(ch^48);
a*=d;
}
int main()
{
int n,x,t;
read(n),read(x),read(t);
if(n%x==0) printf("%d\n",n/x*t);
else printf("%d\n",(n/x+1)*t);
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <vector>
using namespace std;
set<int> guest;
int n, m;
vector<int> people[501];
int main()
{
while((cin >> n >> m) && n && m)
{
int a, b;
int t;
for(int i=0;i<m;i++)
{
cin >> a >> b;
people[a].push_back(b);
people[b].push_back(a);
}
for(int i=0;i<people[1].size();i++)
{
t = people[1][i];
guest.insert(t);
for(int j=0;j<people[t].size();j++) guest.insert(people[t][j]);
}
guest.insert(1);
cout << guest.size()-1 << endl;
guest.clear();
for(int i=0;i<n;i++) people[i].clear();
}
} | #include<bits/stdc++.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
int n,m;
int g[500][500];
int main(){
while(scanf("%d%d",&n,&m),n){
for(int i=0;i<n;i++)
for(int j=0;j<n;j++) g[i][j]=100000;
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
g[a-1][b-1]=1;g[b-1][a-1]=1;
}
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
for(int k=0;k<n;k++) g[j][k]=min(g[j][k],g[j][i]+g[i][k]);
int res=0;
for(int i=1;i<n;i++) if(g[0][i]<=2)res++;
printf("%d\n",res);
}
} | 1 |
#include <bits/stdc++.h>
#define _USE_MATH_DEFINES
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
using namespace std;
class Dice
{
public:
int label[6], tmp;
void in()
{
rep(i, 6) scanf("%d", &label[i]);
}
void rollS()
{
tmp = label[0];
label[0] = label[4];
label[4] = label[5];
label[5] = label[1];
label[1] = tmp;
}
void rollN()
{
tmp = label[0];
label[0] = label[1];
label[1] = label[5];
label[5] = label[4];
label[4] = tmp;
}
void rollE()
{
tmp = label[0];
label[0] = label[3];
label[3] = label[5];
label[5] = label[2];
label[2] = tmp;
}
void rollW()
{
tmp = label[0];
label[0] = label[2];
label[2] = label[5];
label[5] = label[3];
label[3] = tmp;
}
void sideturn()
{
tmp = label[1];
label[1] = label[2];
label[2] = label[4];
label[4] = label[3];
label[3] = tmp;
}
};
bool check2(Dice d1, Dice d2)
{
bool c = true;
FOR(i, 1, 5)
{
c = c && d1.label[i] == d2.label[i];
}
return c;
}
bool check1(Dice d1, Dice d2)
{
bool b = false;
if (d1.label[0] == d2.label[0] && d1.label[5] == d2.label[5])
{
rep(i, 4)
{
b = b || check2(d1, d2);
d2.sideturn();
}
}
return b;
}
bool isSame(Dice d1, Dice d2)
{
bool a = false;
a = a || check1(d1, d2);
d2.rollN();
a = a || check1(d1, d2);
d2.rollE();
a = a || check1(d1, d2);
d2.rollE();
a = a || check1(d1, d2);
d2.rollE();
a = a || check1(d1, d2);
d2.rollN();
a = a || check1(d1, d2);
return a;
}
int main()
{
int n;
bool ans = false;
scanf("%d", &n);
Dice dice[n];
rep(i, n) dice[i].in();
rep(i, n)
{
FOR(j, i + 1, n)
{
ans = ans || isSame(dice[i], dice[j]);
}
}
if (ans)
printf("No\n");
else
printf("Yes\n");
}
| #include<stdio.h>
#include<string.h>
typedef struct {
char direction[100];
int num1,num2,num3,num4,num5,num6;
}DICE_t;
int main(){
int n;
scanf("%d",&n);
DICE_t a[n];
for(int x=0;x<n;x++){
scanf("%d %d %d %d %d %d",&a[x].num1,&a[x].num2,&a[x].num3,&a[x].num4,&a[x].num5,&a[x].num6);
}
int x,y;
for(x=0;x<(n-1);x++){
for(y=(x+1);y<n;y++){
int dummy,turn=0;
while(turn<24){
if(turn%4==0&&turn!=0){
strcpy(a[y].direction,(turn%8==4 ?"SSEN":"ESEN"));
}
else{
strcpy(a[y].direction,"SEN");
}
for(int i=0;a[y].direction[i]!=0;i++){
if(a[y].direction[i]=='N'){
dummy=a[y].num5;
a[y].num5=a[y].num1;
a[y].num1=a[y].num2;
a[y].num2=a[y].num6;
a[y].num6=dummy;
}
else if(a[y].direction[i]=='S'){
dummy=a[y].num6;
a[y].num6=a[y].num2;
a[y].num2=a[y].num1;
a[y].num1=a[y].num5;
a[y].num5=dummy;
}
else if(a[y].direction[i]=='E'){
dummy=a[y].num4;
a[y].num4=a[y].num6;
a[y].num6=a[y].num3;
a[y].num3=a[y].num1;
a[y].num1=dummy;
}
else if(a[y].direction[i]=='W'){
dummy=a[y].num1;
a[y].num1=a[y].num3;
a[y].num3=a[y].num6;
a[y].num6=a[y].num4;
a[y].num4=dummy;
}
}
if(a[x].num1==a[y].num1&&a[x].num2==a[y].num2&&a[x].num3==a[y].num3&&a[x].num4==a[y].num4&&a[x].num5==a[y].num5&&a[x].num6==a[y].num6){
printf("No\n");
goto end;
}
turn++;
}
}
}
printf("Yes\n");
end:
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
int a,b,c;
cin >> a >> b >> c;
rep(i,10){
int cnt = 0;
if(i==a)cnt++;
if(i==b)cnt++;
if(i==c)cnt++;
if(cnt==2){
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| #include<stdio.h>
int main()
{
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if(a==b&&a!=c&&b!=c){
printf("Yes");
}
else if(a==c&&a!=b&&c!=b)
printf("Yes");
else if(b==c&&b!=a&&c!=a)
printf("Yes");
else if(a==b&&a==c&&b==c)
printf("No");
else if(a!=b&&a!=c&&b!=c)
printf("No");
return 0;
} | 1 |
#include <bits/stdc++.h>
int main() {
long long k;
std::cin >> k;
std::cout << 50 << std::endl;
const auto p = k / 50 + 50, q = p - 1 - (k % 50);
for (int i = 0; i < k % 50; i++) {
std::cout << p << " ";
}
for (int i = k % 50; i < 50; i++) {
std::cout << q << " ";
}
std::cout << std::endl;
return 0;
} | #include <iostream>
#include <stdio.h>
#include <fstream>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <vector>
#include <limits.h>
#include <math.h>
#include <functional>
#define repeat(i,n) for (long long i = 0; (i) < (n); ++ (i))
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i] << '\n'
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef vector<int> vint;
typedef vector<ll> vll;
const ll INF = INT_MAX;
const ll MOD = 1e9+7;
int main() {
ll K;
cin >> K;
int N = 50;
vll a(N,N-1);
repeat(i,N){
a[i] += K/N;
}
repeat(i,K%N){
a[i] += N+1;
}
repeat(i,N){
a[i] -= K%N;
}
cout << N << endl;
repeat(i,N){
cout << a[i];
cout <<(i<N-1? " ":"\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
int n;
int a;
int ans=1000000000;
int main(void){
cin>>n;
for(int i=0;i<n;i++){
cin>>a;
int k=0;
while(a%2==0){
a=a/2;
k++;
}
ans=min(ans,k);
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
const int MOD=1e9+7;
const long double Pi=acos(-1);
using P=pair<ll,ll>;
ll gcd(ll a,ll b){//aとbの最大公約数を返す//計算量は0(log(max(a,b))
if(a%b==0){return b;}
else{return gcd(b,a%b);}
}
ll lcm(ll a,ll b){//aとbの最小公倍数を返す//計算量は0(log(max(a,b))
return a*b/gcd(a,b);
}
ll pow(ll x,ll y){//x^yを返す//計算量は0(log(y))
ll tmp=x,res=1;
while(y){
if(y%2){res=res*tmp%MOD;}
y>>=1;
tmp=tmp*tmp%MOD;
}
return res;
}
ll nature(ll a){//絶対値を返す
if(a>=0){return(a);}
else{return(-1*a);}
}
ll prime(ll a){//素数なら1を返す//計算量は0(sqrt(a))
if(a==2){return 1;}
else if(a%2==0 || a==1){return 0;}
for(ll i=3;i*i<=a;i+=2){if(a%i==0){return 0;}}
return 1;
}
vector<int> Z;
void z_algorithm(string str){//計算量はO(str.size())
Z.resize(str.size());
Z.at(0)=str.size();
int m=1,n=0;
while(m<(int)str.size()){
while(m+n<(int)str.size()&&str.at(n)==str.at(m+n)){n++;}
Z.at(m)=n;
if(n==0){
m++;
continue;
}
int k=1;
while(k+Z.at(k)<n){
Z.at(m+k)=Z.at(k);
k++;
}
m+=k;
n-=k;
}
}
vector<vector<int>> vec;
vector<vector<int>> now;
bool dfs(int i){
int ii=now.at(i).at(0);
if(ii==-1){return false;}
if(now.at(ii).at(0)==i){return true;}
else{return false;}
}
int main(){
int N;
cin>>N;
vec.resize(N,vector<int>(N-1));
now.resize(N,vector<int>(0));
vector<int> enemy(N);
for(int i=0;i<N;i++){
for(int j=0;j<N-1;j++){
int a;
cin>>a;
vec.at(i).at(j)=a-1;
if(j==0){
now.at(i).push_back(a-1);
}
}
enemy.at(i)=0;
}
ll count=0;
ll day=0;
//countはN(N-1)/2まで
while(count<N*(N-1)/2){
unordered_map<int,int> mp;
int memo=count;
day++;
for(int i=0;i<N;i++){
//cout<<count<<" "<<i<<endl;
if(dfs(i) && mp[i]==0 && mp[now.at(i).at(0)]==0 && now.at(i).at(0)!=-1){
count++;
int a=i;
int b=now.at(i).at(0);
enemy.at(a)++;
enemy.at(b)++;
mp[a]=1;
mp[b]=1;
//cout<<a<<" "<<b<<" "<<enemy.at(a)<<" "<<enemy.at(b)<<endl;
if(enemy.at(a)<N-1){
//cout<<a<<" "<<b<<" "<<enemy.at(a)<<endl;
now.at(a).at(0)=vec.at(a).at(enemy.at(a));
}
else{
now.at(a).at(0)=-1;
}
if(enemy.at(b)!=N-1){
//cout<<" "<<a<<" "<<b<<" "<<enemy.at(b)<<endl;
now.at(b).at(0)=vec.at(b).at(enemy.at(b));
}
else{
now.at(b).at(0)=-1;
}
}
}
if(memo==count){
cout<<-1<<endl;
return 0;
}
mp.clear();
}
cout<<day<<endl;
} | 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; cin >> N;
if (N == 0) break;
vector< vector<bool> > a(21, vector<bool>(21));
int cnt = N;
while (N--) {
int x, y; cin >> x >> y;
a[y][x] = true;
}
int x = 10, y = 10;
int M; cin >> M;
while (M--) {
string d; int l; cin >> d >> l;
int dx = 0, dy = 0;
if (d == "N") dy = 1;
if (d == "E") dx = 1;
if (d == "S") dy = -1;
if (d == "W") dx = -1;
while (l--) {
x += dx; y += dy;
if (a[y][x]) {
a[y][x] = false;
cnt--;
}
}
}
cout << (cnt == 0 ? "Yes" : "No") << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll,ll> l_l;
const int INF=1001001000;
const int mINF=-1001001000;
const ll LINF=1010010010010010000;
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;
string s;cin >> s;
vector<int> a(n);
for(int i=0;i<n;i++) a[i]=(s[i]=='o');
for(int ti=0;ti<2;ti++){
for(int tj=0;tj<2;tj++){
vector<int> b(n);
b[0]=ti,b[1]=tj;
for(int i=0;i<n;i++){
int j=(i+1)%n;
b[(i+2)%n]=b[i]^b[j]^a[j];
}
if(b[0]==ti&&b[1]==tj){
string ans="";
for(int i=0;i<n;i++) ans+="WS"[b[i]];
cout << ans << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int a, b, c, N;
int flag[3][1000], judge[1000], info[301];
while(cin >> a >> b >> c , a+b+c){
fill_n(info,301,2);
cin >> N;
for(int i = 0 ; i < N ; i++ ){
for(int j = 0 ; j < 3 ; j++) cin >> flag[j][i];
cin >> judge[i];
if(judge[i] == 1) for(int j = 0 ; j < 3 ; j++ ) info[flag[j][i]] = 1;
}
for(int i = 0 ; i < N ; i++ ){
if(!judge[i]){
for(int j = 0 ; j < 3 ; j++){
if(info[flag[j][i]] == 1 && info[flag[(j+1)%3][i]] == 1){
info[flag[(j+2)%3][i]] = 0;
}
}
}
}
for(int i = 1 ; i <= a+b+c ; i++ ) cout << info[i] << endl;
}
} | #include<iostream>
using namespace std;
int main(){
int a[1111], b[1111], c[1111], d[1111], p[333], n;
while(cin >> a[0] >> b[0] >> c[0], *a+=*b+*c){
for(int i=332;i;) p[i--] = 2;
cin >> n;
for(int i=0;i++<n;) cin >> a[i] >> b[i] >> c[i] >> d[i];
for(int i=0;i++<n;){
for(int j=0;j++<n;){
if(d[j]) p[a[j]] = p[b[j]] = p[c[j]] = 1;
else{
if(p[a[j]] == 1 && p[b[j]] == 1) p[c[j]] = 0;
if(p[a[j]] == 1 && p[c[j]] == 1) p[b[j]] = 0;
if(p[b[j]] == 1 && p[c[j]] == 1) p[a[j]] = 0;
}
}
}
for(int i=0;i<*a;) cout << p[++i] << endl;
}
} | 1 |
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
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++)
typedef long double ld;
typedef complex<ld> Point;
const ld eps = 1e-11;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
typedef unsigned long long ul;
struct SegT {
private:
int n; vector<ll> node, lazy;
const ll init_c = INF/16;
public:
SegT(int sz) {
n = 1;
while (n < sz)n <<= 1;
node.resize(2 * n - 1, init_c);
lazy.resize(2 * n - 1, 0);
}
ll f(ll a, ll b) {
return min(a, b);
}
void eval(int k, int l, int r) {
node[k] += lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] += lazy[k];
lazy[2 * k + 2] += lazy[k];
}
lazy[k] = 0;
}
void add(ll x, int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)r = n;
eval(k, l, r);
if (r <= a || b <= l)return;
if (a <= l && r <= b) {
lazy[k] += x; eval(k, l, r);
}
else {
add(x, a, b, k * 2 + 1, l, (l + r) / 2);
add(x, a, b, k * 2 + 2, (l + r) / 2, r);
node[k] = f(node[k * 2 + 1], node[k * 2 + 2]);
}
}
ll query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)r = n;
eval(k, l, r);
if (r <= a || b <= l)return INF;
if (a <= l && r <= b)return node[k];
else {
ll vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
}
void update(int k, ll x) {
ll z = query(k, k + 1);
add(x - z, k, k + 1);
//cout << query(k, k + 1) << endl;
//cout << "hello" << k << " " << z << endl;
}
ll specialquery(int m) {
ll res = INF;
rep(i, m) {
res = min(res, query(i,i+1) + i);
}
return res;
}
};
int n, q;
ll dp[1 << 18];
int main() {
cin >> n >> q;
int a, b; cin >> a >> b; a--; b--;
fill(dp, dp + n, INF);
int x; cin >> x; x--;
dp[a] = abs(b - x); dp[b] = abs(a - x);
SegT l(n), r(n);
l.update(a, dp[a]-a); r.update(a, dp[a]+a);
l.update(b, dp[b]-b); r.update(b, dp[b]+b);
int memo = x;
//cout << l.specialquery(n) << endl;
//cout << r.query(memo, n) - memo << endl;
rep(i, q - 1) {
cin >> x; x--;
ll vl = l.query(0, x) + x;
ll vr = r.query(x, n) - x;
//cout << memo << " " << vl << " " << vr << endl;
dp[memo] = min(vl, vr);
//cout << memo << " " << dp[memo] << endl;
l.add(abs(memo - x),0,memo); r.add(abs(memo - x), 0, memo);
l.add(abs(memo - x), memo + 1, n); r.add(abs(memo - x), memo + 1, n);
r.update(memo, dp[memo] + memo);
//cout << memo << " " << dp[memo] - memo << endl;
l.update(memo, dp[memo] - memo);
memo = x;
//cout << l.specialquery() << endl;
}
/*cout << l.query(4, 5) + 4 << endl;
l.update(4, 3);
cout << l.query(4, 5) + 4 << endl;
l.specialquery(n);*/
cout << l.specialquery(n) << endl;
//cout << memo << endl;
//stop
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(ll i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;
int main(){
cin.tie(0); ios::sync_with_stdio(false);
ll n, lbuf, rbuf, mi;
cin >> n;
P lr[n];
ll ans = 0;
zep(i, 0, n){
cin >> lbuf >> rbuf;
lr[i] = P(rbuf, lbuf);
if(rbuf-lbuf+1 > ans){
ans = rbuf-lbuf+1;
mi = i;
}
}
ll lm = 0;
ll rm = 1e9;
zep(i, 0, n){
if(i != mi){
lm = max(lr[i].second, lm);
rm = min(lr[i].first, rm);
}
}
ans += max(rm-lm+1, 0LL);
sort(lr, lr+n);
zep(i, 0, n){
ll tmp = lr[i].first;
lr[i].first = lr[i].second;
lr[i].second = tmp;
}
ll al[n], dl[n], ar[n], dr[n];
al[0] = lr[0].first;
ar[0] = lr[0].second;
zep(i, 1, n){
al[i] = max(lr[i].first, al[i-1]);
ar[i] = min(lr[i].second, ar[i-1]);
}
dl[n-1] = lr[n-1].first;
dr[n-1] = lr[n-1].second;
rrep(i, n-2, 0){
dl[i] = max(lr[i].first, dl[i+1]);
dr[i] = min(lr[i].second, dr[i+1]);
}
zep(i, 0, n-1){
ans = max(ar[i]-al[i]+1+dr[i+1]-dl[i+1]+1, ans);
}
print(ans)
return 0;
} | 0 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N,Q,K;
cin>>N;
vector<vector<pair<int,int>>> A(N);
for(int i=1;i<N;i++){
int a,b,c;
cin>>a>>b>>c;
A[a-1].push_back({b-1,c});
A[b-1].push_back({a-1,c});
}
cin>>Q>>K;
vector<int> B(N,-1);
queue<int> q;
B[K-1]=0;
q.push(K-1);
while(!q.empty()){
int I=q.front();
q.pop();
for(pair<int,int> p:A[I])
if(B[p.first]==-1){
B[p.first]=B[I]+p.second;
q.push(p.first);
}
}
while(Q--){
int x,y;
cin>>x>>y;
cout<<B[x-1]+B[y-1]<<endl;
}
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
//constructor: LCA(graph);
template<class T>
class LCA_weight {
private:
int n;
int D = 30; //hight
vector<int> depth; //depth from root
vector<vector<pair<int,T>>> hen; //tree
vector<vector<int>> par; //doubling array
vector<T> dista; //distance form root
void dfs(int v, int p, int dep, T dep_dist) {
par[v][0] = p;
depth[v] = dep;
dista[v] = dep_dist;
for(auto i : hen[v]) {
if(i.first == p)continue;
dfs(i.first, v, dep + 1, dep_dist + i.second);
}
}
public:
LCA_weight(const vector<vector<pair<int,T>>>& hen):hen(hen) {
n = hen.size();
par.resize(n, vector<int>(D + 1));
depth.resize(n);
dista.resize(n);
dfs(0, -1, 0, 0);
for(int i = 0; i < D; i++) {
for(int j = 0; j < n; j++) {
if(par[j][i] == -1)par[j][i + 1] = -1;
else par[j][i + 1] = par[par[j][i]][i];
}
}
}
//go back to root
int back(int v, int dist) {
for(int i = 0; i < D; i++)if((1 << i) & dist) {
if(v == -1)return v;
v = par[v][i];
}
return v;
}
//get LCA
int get(int u, int v) {
int ret = 0;
if(depth[u] > depth[v])swap(u, v);
ret = depth[v] - depth[u];
v = back(v, ret);
if(u == v)return v;
for(int i = D; i >= 0; i--) {
if(par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
}
return par[u][0];
}
//u-v path distance
T dist(int u, int v) {
int lca = get(u, v);
return (dista[u] + dista[v]) - dista[lca] * 2;
}
//print parents
void print(int i) {
cerr << "[";
for(int j = 0; j < n; j++)cerr << par[j][i] << (j == n - 1 ? "" : ",");
cerr << "]";
}
};
int main()
{
int n; cin >> n;
vector<vector<pair<int,ll>>> hen(n);
for(int i = 0; i < n - 1; i++) {
int a, b, c; cin >> a >> b >> c;
a--, b--;
hen[a].emplace_back(b, c);
hen[b].emplace_back(a, c);
}
LCA_weight<ll> lca(hen);
int q, k; cin >> q >> k;
k--;
while(q--) {
int s, t; cin >> s >> t; s--, t--;
cout << lca.dist(s, k) + lca.dist(t, k) << endl;
}
} | 1 |
#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>;
const long long INF = 1ll << 60;
int main() {
string S; cin >>S;
ll ans = INF;
rep(i,S.size()-2){
ll ints = stoi(S.substr(i,3));
ans = min(ans,abs(753 - ints));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int intinput() {
int x;
cin >> x;
return x;
}
vector<int> forintinput(int n) {
vector<int> x(100000);
for(int i = 0;i < n;i++) cin >> x[i];
return x;
}
int main(){
vector<int> s(10);
string ss;
cin >> ss;
for(int i = 0;i < ss.length();i++){
s[i] = ss.at(i) - '0';
}
int cnt =100000;
for(int i = 0;i < ss.length()-2;i++){
if(100*s[i] + 10*s[i+1] + s[i+2] -753 <= 0){
if((100*s[i] + 10*s[i+1] + s[i+2] - 753)*-1 < cnt){
cnt = (100*s[i] + 10*s[i+1] + s[i+2] - 753)*-1;
}
}else{
if(100*s[i] + 10*s[i+1] + s[i+2] - 753 < cnt){
cnt = 100*s[i] + 10*s[i+1] + s[i+2] - 753;
}
}
}
cout << cnt << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
#define rrep(i, m, n) for(int (i)=(m); (i)<(n); (i)++)
#define erep(i, m, n) for(int (i)=(m); (i)<=(n); (i)++)
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
#define rrev(i, m, n) for(int (i)=(n)-1; (i)>=(m); (i)--)
#define erev(i, m, n) for(int (i)=(n); (i)>=(m); (i)--)
#define rev(i, n) for(int (i)=(n)-1; (i)>=0; (i)--)
#define vrep(i, c) for(__typeof((c).begin())i=(c).begin(); i!=(c).end(); i++)
#define ALL(v) (v).begin(), (v).end()
#define mp make_pair
#define pb push_back
template<class T, class S> inline bool minup(T& m, S x){ return m>(T)x ? (m=(T)x, true) : false; }
template<class T, class S> inline bool maxup(T& m, S x){ return m<(T)x ? (m=(T)x, true) : false; }
const int INF = 1000000000;
const ll MOD = 1000000007LL;
const double EPS = 1E-12;
const int MAX_N = 13;
const int n = MAX_N;
const int m = 5;
int card[MAX_N];
vi x(m);
string judge(vi num)
{
if(num[0] == 4) return "four card";
if(num[0] == 3 && num[1] == 2) return "full house" ;
if(num[0] == 1 && x[4] - x[0] == 4) return "straight";
if(num[0] == 1 && x[0] == 0 && x[1] == 9 && x[4] == 12) return "straight";
if(num[0] == 3) return "three card";
if(num[0] == 2 && num[1] == 2) return "two pair";
if(num[0] == 2) return "one pair";
return "null";
}
int main()
{
rep(i, n) card[i] = i;
while(~scanf("%d,%d,%d,%d,%d", &x[0], &x[1], &x[2], &x[3], &x[4], &x[5])){
vi num(MAX_N);
rep(i, m) x[i] -= 1;
rep(i, m) num[x[i]] += 1;
sort(ALL(num), greater<int>());
sort(ALL(x));
cout << judge(num) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> x(3);
int k, y;
for(int i=0;i<3;i++) cin >> x.at(i);
cin >> k;
sort(x.begin(), x.end());
y = x.at(2);
for(int i=0;i<k;i++) y = 2*y;
cout << x.at(0) + x.at(1) + y << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//#define rep(i, n) for (ll i = 0; i < (n); ++i)
//typedef pair<ll, ll> P;
typedef pair<double, double> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) {
return fabs(a - b) < DBL_EPSILON;
}
std::istream &operator>>(std::istream &in, set<string> &o) {
string a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
//ofstream outfile("log.txt");
//outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0') << rank << endl;
// std::cout << std::bitset<8>(9);
//const ll mod = 1e10;
typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;
int main() {
int x, y;
cin >> x >> y;
auto f = [](int i) {
if (i == 3) return 100000;
if (i == 2) return 200000;
if (i == 1) return 300000;
return 0;
};
int ans = [&] {
if (x == 1 && y == 1) return 1000000;
return f(x) + f(y);
}();
cout << ans << endl;
}
| #include<stdio.h>
#include<string.h>
int main(){
int a,b,total=0;
scanf("%d %d",&a,&b);
char s[a+b+2];
scanf("%s", &s);
for(int i=0; i<a+b+1 ;i++){
if(i!=a){
if(s[i]>=48 && s[i]<=57){
total++;
}
}
else {
if(s[i] == '-'){
total++;
}
}
}
if (total==a+b+1){
printf("Yes");
}
else {
printf("No");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
int n,m,x,y;
cin>>n>>m>>x>>y;
int cnt;
int sum;
string ans="War";
vector<int> a(n);
rep(i,n){
cin>>a[i];
}
vector<int> b(m);
rep(i,m){
cin>>b[i];
}
for(int i=x+1;i<y;i++){
cnt=0;
for(int j=0;j<n;j++){
if(i>a[j]) cnt++;
}
sum=0;
if(cnt==n){
for(int j=0;j<m;j++){
if(i<=b[j]) sum++;
}
}
if(sum==m) ans="No War";
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T>
inline bool chmax(T &a, T b){if (a < b){a = b;return 1;}return 0;}
template <typename T>
inline bool chmin(T &a, T b){if (a > b){a = b;return 1;}return 0;}
int main(){
ll n,m,x,y;cin>>n>>m>>x>>y;
bool yes=true;
vector<ll> x_vec(n),y_vec(m);
rep(i,n) cin>>x_vec[i];
rep(i,m) cin>>y_vec[i];
for(ll z=-100;z<=100;z++){
bool Yes=false;
if(!(x<z && z<=y)) Yes=true;
rep(i,n) if(!(x_vec[i]<z)) Yes=true;
rep(i,m) if(!(y_vec[i]>=z)) Yes=true;
if(!Yes){
yes=false;
break;
}
}
if(yes) cout<<"War"<<endl;
else cout<<"No War"<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
// blue input
int n;
cin >> n;
vector<string> blue(n);
for(int i = 0; i < n; i++) {
cin >> blue.at(i);
}
// red input
int m;
cin >> m;
vector<string> red(m);
for(int i = 0; i < m; i++) {
cin >> red.at(i);
}
int max = 0;
for(int i = 0; i < n; i++) {
string s = blue.at(i);
int cnt = 0;
for(int j = 0; j < n; j++) {
if(s == blue.at(j)){
cnt++;
}
}
for(int k = 0; k < m; k++) {
if(s == red.at(k)){
cnt--;
}
}
if(cnt >= max){
max = cnt;
}
}
cout << max << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll dfs(ll prev, ll now, vector<vector<ll>>& adj, vector<ll>& dp, set<ll>& st) {
if (dp[now] > 0) return dp[now];
if (st.find(now) != st.end()) return -1;
st.insert(now);
ll ret = 0;
for (auto i : adj[now]) {
if (i == prev) continue;
ll x = dfs(now, i, adj, dp, st);
if (x == -1) return -1;
ret = max(ret, x);
}
st.erase(now);
return dp[now] = ret + 1;
}
int main() {
ll n;
cin >> n;
vector<vector<ll>> a(n, vector<ll>(n - 1));
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n - 1; j++) {
cin >> a[i][j];
a[i][j]--;
}
}
auto idx = [&] (ll i, ll j) {
if (i > j) swap(i, j);
ll ret = n * (n - 1) / 2 - (n - i) * (n - i - 1) / 2;
return ret + j - i - 1;
}; // {i, j} が対戦する試合の頂点番号
ll m = n * (n - 1) / 2;
vector<vector<ll>> adj(m);
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n - 2; j++) {
ll u = idx(i, a[i][j]), v = idx(i, a[i][j + 1]);
adj[u].push_back(v);
}
}
vector<ll> dp(m, 0);
ll ans = 0;
for (ll i = 0; i < m; i++) {
set<ll> st;
ll x = dfs(-1, i, adj, dp, st);
if (x == -1) {
cout << -1 << endl;
return 0;
} else ans = max(ans, x);
}
cout << ans << endl;
} | 0 |
#include <cmath>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
string s;
void input() {
cin >> s;
}
void solve() {
string ans = "No";
if (s.find('7') != string::npos)
ans = "Yes";
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(16);
cout << fixed;
int _times = 1;
#ifdef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
_times = 2;
#endif
// cin >> _times;
while (_times--) {
input();
solve();
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
if(N%10 == 7||N%100 == 70||N%100 == 71||N%100 == 72||N%100 == 73||N%100 == 74||N%100 == 75||N%100 == 76||N%100 == 78||N%100 == 79||N/100 == 7){
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
} | 1 |
#include <bits/stdc++.h>
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define reprrev(i,a,b) for(int i=b-1;i>=a;i--) // [a, b)
#define reprev(i,n) reprrev(i,0,n)
#define _GLIBCXX_DEBUG
using ll = long long;
using ull = unsigned long long;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const ll mod = 1e9+7;
void chmod(ll &M){
if(M >= mod) M %= mod;
else if(M < 0){
M += (abs(M)/mod + 1)*mod;
M %= mod;
}
}
ll modpow(ll x, ll n){
if(n==0) return 1;
ll res=modpow(x, n/2);
if(n%2==0) return res*res%mod;
else return res*res%mod*x%mod;
}
int getl(int i, int N) { return i==0? N-1:i-1; };
int getr(int i, int N) { return i==N-1? 0:i+1; };
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
using namespace std;
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
int main()
{
int K, X;
cin >> K >> X;
cerr << K << " " << X << " " << X - K + 1 << X + K << "\n";
for (int i = X - K + 1; i < X + K; i++) {
if(i == X + K - 1) cout << i << "\n";
else cout << i << " ";
}
} | #include <bits/stdc++.h>
using namespace std;
int main (){
int k,x;
cin >> k >> x;
for(int i=1;i<=k*2-1;i++){
cout << x-k+i << " ";
}
cout << endl;
} | 1 |
/**
* @copyright (c) 2020 Daisuke Hashimoto
*/
#include <bits/stdc++.h>
using namespace std;
using Pair = pair<int64_t, int64_t>;
constexpr int64_t kInf = INT64_MAX / 2L;
// std::cout << std::setprecision(20) << 1.1 << endl;
const int64_t dxs[] = {-1, 1, 0, 0};
const int64_t dys[] = {0, 0, -1, 1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
// 1********
for (int64_t i = 0; i < (tx - sx); ++i) {
cout << "R";
}
for (int64_t i = 0; i < ty - sy; ++i) {
cout << "U";
}
// 2********
for (int64_t i = 0; i < (tx - sx); ++i) {
cout << "L";
}
for (int64_t i = 0; i < ty - sy; ++i) {
cout << "D";
}
// 3********
cout << "D";
for (int64_t i = 0; i < (tx - sx) + 1; ++i) {
cout << "R";
}
for (int64_t i = 0; i < ty - sy + 1; ++i) {
cout << "U";
}
cout << "L";
// 4********
cout << "U";
for (int64_t i = 0; i < (tx - sx) + 1; ++i) {
cout << "L";
}
for (int64_t i = 0; i < ty - sy + 1; ++i) {
cout << "D";
}
cout << "R";
cout << endl;
return 0;
}
|
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
typedef unsigned long long ULLONG;
typedef long long LLONG;
static const LLONG MOD_NUM = 1000000007;
template<class _T> static void getval(_T& a) {
std::cin >> a;
}
template<class _T> static void getval(_T& a, _T& b) {
std::cin >> a >> b;
}
template<class _T> static void getval(_T& a, _T& b, _T& c) {
std::cin >> a >> b >> c;
}
template <class _T> static _T tp_abs(_T a) {
if (a < (_T)0) {
a *= (_T)-1;
}
return a;
}
template <class _T> static void tp_swap(_T& right, _T& left) {
// usage: tp_swap<type name>(a, b);
_T tmp = right;
right = left;
left = tmp;
}
static void exec();
int main()
{
exec();
fflush(stdout);
return 0;
}
static void exec()
{
int sx, sy, tx, ty;
getval(sx, sy);
getval(tx, ty);
int dx = tx - sx;
int dy = ty - sy;
std::string ans;
for (int i = 0; i < dx; i++) {
ans += 'R';
}
for (int i = 0; i < dy; i++) {
ans += 'U';
}
for (int i = 0; i < dx; i++) {
ans += 'L';
}
for (int i = 0; i < dy; i++) {
ans += 'D';
}
ans += 'D';
for (int i = 0; i <= dx; i++) {
ans += 'R';
}
for (int i = 0; i <= dy; i++) {
ans += 'U';
}
ans += 'L';
ans += 'U';
for (int i = 0; i <= dx; i++) {
ans += 'L';
}
for (int i = 0; i <= dy; i++) {
ans += 'D';
}
ans += 'R';
std::cout << ans << std::endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
int n, a[3], cnt, ed;
int f[50][1 << 17], ans = 1;
inline int add(const int &x, const int &y) {
return x + y < mod ? x + y : x + y - mod;
}
inline int sub(const int &x, const int &y) {
return x - y < 0 ? x - y + mod : x - y;
}
inline int mul(const int &x, const int &y) { return (int)((ll)x * y % mod); }
int main() {
scanf("%d%d%d%d", &n, &a[0], &a[1], &a[2]);
for(int i = 1; i <= n; i++) ans = mul(ans, 10);
cnt = (1 << a[0] + a[1] + a[2]) - 1;
ed = (1 << a[0] - 1) | (1 << a[0] + a[1] - 1) | (1 << a[0] + a[1] + a[2] - 1);
f[0][0] = 1;
for(int i = 1; i <= n; i++)
for(int j = 0; j <= cnt; j++)
for(int k = 1; k <= 10; k++) {
int t = (j << k) + (1 << k - 1); t &= cnt;
if((t & ed) != ed) f[i][t] = add(f[i - 1][j], f[i][t]);
}
for(int i = 0; i <= cnt; i++) ans = sub(ans, f[n][i]);
printf("%d\n", ans);
return 0;
} | #pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include "bits/stdc++.h"
using namespace std;
#define pb push_back
#define F first
#define S second
#define f(i,a,b) for(int i = a; i < b; i++)
// #define endl '\n'
using ll = long long;
using db = long double;
using ii = pair<int, int>;
const int N = 55, LG = 17, MOD = 1e9+7;
const int SQ = 320;
const long double EPS = 1e-7;
int cnt = 0;
vector<string> store[11];
void bt(string s = "", int sum = 0){
if(sum > 7)return;
store[sum].pb(s);
f(i,0,7){
s.pb('0' + i);
bt(s,sum+i+1);
s.pop_back();
}
}
const int M = 10;
int trie[N*N*N][M];
int go[N*N*N][M];
int mrk[N*N*N], f[N*N*N];
int ptr = 1;
void BFS(){
queue<int> q;
for(int i = 0; i < M; i++)
if(trie[0][i])
q.push(trie[0][i]), f[trie[0][i]] = 0;
for(int i = 0; i < M; i++) go[0][i] = trie[0][i];
while(!q.empty()) {
int x = q.front(); q.pop();
for(int i = 0; i < M; i++) {
if(trie[x][i]) {
int y = trie[x][i];
f[y] = f[x];
while(f[y] && !trie[f[y]][i])
f[y] = f[f[y]];
if(trie[f[y]][i]) f[y] = trie[f[y]][i];
q.push(y);
}
if(trie[x][i]) go[x][i] = trie[x][i];
else go[x][i] = go[f[x]][i];
}
}
}
void ins(string x){
int cur = 0;
for(int i = 0; i < x.size(); i++){
if(!trie[cur][x[i]-'0'])
trie[cur][x[i]-'0'] = ptr++;
cur = trie[cur][x[i]-'0'];
}
mrk[cur] = true;
}
int dp[N][N*N*N][2];
int n, x, y, z;
int solve(int idx, int state, bool f){
f|=mrk[state];
if(idx == n)
return f;
int &ret = dp[idx][state][f];
if(~ret)
return ret;
ret = 0;
f(j,0,10){
ret += solve(idx+1,go[state][j], f);
if(ret>=MOD)ret-=MOD;
}
return ret;
}
int32_t main(){
#ifdef ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(0);
#endif // ONLINE_JUDGE
bt();
cin >> n >> x >> y >> z;
for(auto X : store[x])
for(auto Y : store[y])
for(auto Z : store[z])if(X.size()+Y.size()+Z.size()<=n)
ins(X+Y+Z);
BFS();
memset(dp,-1,sizeof dp);
cout << solve(0,0,0) << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin>>s;
int n=s.size();
for(int i=0;i<(1<<(n-1));i++){
int ans=s[0]-'0';
vector<char> enzan;
for(int j=0;j<n-1;j++){
if(i&(1<<j)){
ans-=s[j+1]-'0';
enzan.push_back('-');
}else{
ans+=s[j+1]-'0';
enzan.push_back('+');
}
}
if(ans==7){
cout<<s[0]<<enzan[0]<<s[1]<<enzan[1]<<s[2]<<enzan[2]<<s[3]<<'='<<7<<endl;
return 0;
}
}
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n, prime[10001], p[10001];
fill(prime, prime+10001, 1);
fill(p, p+10001, 0);
prime[0] = 0;
prime[1] = 0;
for(int i=2; i<10001; i++){
if(prime[i] == 1){
if(prime[i-2] == 1) p[i] = 1;
for(int j=2; i*j<10001; j++){
prime[i*j] = 0;
}
}
}
while(cin >> n){
if(n == 0) break;
for(int i=n; i>0; i--){
if(p[i] == 1) {
cout << i-2 << " " << i << endl;
break;
}
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); ++i)
using ll = long long;
using P = pair<int, int>;
int main(){
int n;
ll y;
cin >> n >> y;
int a,b,c;
a=-1;
b=-1;
c=-1;
int cnt=0;
for(int i=0;i<=n;i++){
for(int j=0;j<=n-i;j++){
if((1000*i+5000*j+10000*(n-i-j))==y){
a=n-i-j;
b=j;
c=i;
}
}
}
cout << a << " " << b << " " << c << endl;
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
int main(){
int data[100],cnt=0,n;
cin >> n;
for(int i=0;i<n;i++) cin >> data[i];
for(int i=0;i<n;i++){
for(int j=n-1;j>i;j--){
if(data[j]<data[j-1]){
swap(data[j],data[j-1]);
cnt++;
}
}
}
for(int i=0;i<n;i++){
cout << (i!=0?" ":"") << data[i];
}
cout << endl << cnt << endl;
} | 0 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
//#include<boost/multiprecision/cpp_int.hpp>
//#include<boost/multiprecision/cpp_dec_float.hpp>
//namespace mp=boost::multiprecision;
//#define mulint mp::cpp_int
//#define mulfloat mp::cpp_dec_float_100
using namespace std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
constexpr int MOD=1000000007;
//constexpr int MOD=998244353;
#define INF (1<<30)
#define LINF (lint)(1LL<<56)
#define endl "\n"
#define rep(i,n) for(lint (i)=0;(i)<(n);(i)++)
#define reprev(i,n) for(lint (i)=(n-1);(i)>=0;(i)--)
#define Flag(x) (1<<(x))
#define Flagcount(x) __builtin_popcountll(x)
#define pint pair<int,int>
#define pdouble pair<double,double>
#define plint pair<lint,lint>
#define fi first
#define se second
typedef long long lint;
int dx[8]={1,1,0,-1,-1,-1,0,1};
int dy[8]={0,1,1,1,0,-1,-1,-1};
const int MAX_N=2e5+5;
//struct edge{lint to,num;};
vector<lint> G[200050]; // MAX_V,隣接リスト
lint root;
lint parent[20][200050]; // logMAX_V,MAX_V
lint depth[200050];
void LCAdfs(lint v,lint p,lint d){
parent[0][v]=p;
depth[v]=d;
rep(i,G[v].size()) if(G[v][i]!=p) LCAdfs(G[v][i],v,d+1);
}
void LCAinit(lint V){
LCAdfs(root,-1,0);
for(int k=0;k+1<20;k++){
for(int v=0;v<V;v++){
if(parent[k][v]<0) parent[k+1][v]=-1;
else parent[k+1][v]=parent[k][parent[k][v]];
}
}
}
lint LCA(lint u,lint v){
if(depth[u]>depth[v]) swap(u,v);
for(int k=0;k<20;k++){
if((depth[v]-depth[u])>>k&1) v=parent[k][v];
}
if(u==v) return u;
for(int k=20-1;k>=0;k--){
if(parent[k][u]!=parent[k][v]){
u=parent[k][u];
v=parent[k][v];
}
}
return parent[0][u];
}
vector<int> path(int s,int t){
int lca=LCA(s,t);
vector<int> ps,pt;
int now=s;
while(true){
if(now==lca) break;
ps.push_back(now);
now=parent[0][now];
}
now=t;
while(true){
pt.push_back(now);
if(now==lca) break;
now=parent[0][now];
}
reverse(pt.begin(),pt.end());
ps.insert(ps.end(),pt.begin(),pt.end());
return ps;
}
vector<pint> edge[MAX_N];
bool reach[MAX_N];
lint dis[MAX_N];
void dfs(int now,lint sum){
if(reach[now]) return;
reach[now]=true;
dis[now]=sum;
rep(i,edge[now].size()){
dfs(edge[now][i].fi,sum+edge[now][i].se);
}
}
int main(void){
int N;
cin >> N;
rep(i,N-1){
int u,v,w;
cin >> u >> v >> w;
u--,v--;
G[u].push_back(v);
G[v].push_back(u);
edge[u].push_back(pint(v,w));
edge[v].push_back(pint(u,w));
}
LCAinit(N);
dfs(0,0);
int Q,K;
cin >> Q >> K;
K--;
rep(i,Q){
int x,y;
cin >> x >> y;
x--,y--;
int lca=LCA(x,K);
lint ans=dis[x]+dis[K]-2*dis[lca];
lca=LCA(K,y);
ans+=dis[K]+dis[y]-2*dis[lca];
cout << ans << endl;
}
} | #include<iostream>
#include<cstdio>
#include<vector>
#include<cmath>
#include<cstring>
#include<fstream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int INF=0x3f3f3f3f;
const int MAXN=1e5+5;
int tot,head[MAXN];
LL dist[MAXN];
bool vis[MAXN];
struct Edge
{
int from,to,nxt;
LL cost;
}e[MAXN*2];
void addedge(int u,int v,int w)
{
e[tot].from=u;
e[tot].to=v;
e[tot].cost=w;
e[tot].nxt=head[u];
head[u]=tot++;
}
void dfs(int u,int fa)
{
for(int i=head[u];i!=-1;i=e[i].nxt)
{
int to=e[i].to;
if(to==fa) continue;
dist[to]=dist[u]+e[i].cost;
dfs(to,u);
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
tot=0;
memset(head,-1,sizeof(head));
memset(dist,0,sizeof(dist));
int u,v;
LL w;
for(int i=1;i<=n-1;i++)
{
scanf("%d%d%lld",&u,&v,&w);
addedge(u,v,w);
addedge(v,u,w);
}
int q,k;
scanf("%d%d",&q,&k);
dfs(k,-1);
// for(int i=1;i<=n;i++)
// cout<<dist[i]<<" ";
// cout<<endl;
int x,y;
for(int i=1;i<=q;i++)
{
scanf("%d%d",&x,&y);
printf("%lld\n",dist[x]+dist[y]);
}
}
return 0;
} | 1 |
#include<iostream>
#include<sstream>
using namespace std;
int s2d(string buf){
istringstream iss(buf);
double x;iss >> x;
return x;
}
int main(){
string buf;
while(cin>>buf){
int i;
for(i=0;i<buf.size();i++) if(buf[i]==',') buf[i]=' ';
stringstream ss(buf);
double d[12];
for(i=0;i<12;i++){
ss >> buf;
d[i]=s2d(buf);
//cout << i << ":" << d[i] << endl;
}
double p=0;
for(i=0;i<10;i++) p+=d[i];
p*=d[10]/(d[10]+d[11]);
//cout << p << endl;
int o=0,k=0;
for(i=0;i<10;i++){
if(p<=k+d[i]){
o=i+1;
break;
}
k+=d[i];
}
cout << o << endl;
}
return 0;
} | #include<stdio.h>
#include<string.h>
int main()
{
int m,n, N;
int dice[101][101];
scanf("%d", &N);
for (n = 0; n < N; n++)
{
for (m = 0; m < 6; m++)
{
scanf("%d", &dice[n][m]);
}
}
int i = 4, tmp, j = 4;
for (n = 0; n < N - 1; n++)
{
for (m = n + 1; m < N; m++)
{
while (i--)
{
if (dice[n][0] == dice[m][0]
&& dice[n][1] == dice[m][1]
&& dice[n][2] == dice[m][2]
&& dice[n][3] == dice[m][3]
&& dice[n][4] == dice[m][4]
&& dice[n][5] == dice[m][5])
{
printf("No\n");
return 0;
}
while (j--)
{
tmp = dice[n][1];
dice[n][1] = dice[n][2];
dice[n][2] = dice[n][4];
dice[n][4] = dice[n][3];
dice[n][3] = tmp;
if (dice[n][0] == dice[m][0]
&& dice[n][1] == dice[m][1]
&& dice[n][2] == dice[m][2]
&& dice[n][3] == dice[m][3]
&& dice[n][4] == dice[m][4]
&& dice[n][5] == dice[m][5])
{
printf("No\n");
return 0;
}
}
j = 4;
if (i % 2 == 0)
{
tmp = dice[n][0];
dice[n][0] = dice[n][1];
dice[n][1] = dice[n][5];
dice[n][5] = dice[n][4];
dice[n][4] = tmp;
if (dice[n][0] == dice[m][0]
&& dice[n][1] == dice[m][1]
&& dice[n][2] == dice[m][2]
&& dice[n][3] == dice[m][3]
&& dice[n][4] == dice[m][4]
&& dice[n][5] == dice[m][5])
{
printf("No\n");
return 0;
}
}
if (i % 2 == 1)
{
tmp = dice[n][0];
dice[n][0] = dice[n][2];
dice[n][2] = dice[n][5];
dice[n][5] = dice[n][3];
dice[n][3] = tmp;
if (dice[n][0] == dice[m][0]
&& dice[n][1] == dice[m][1]
&& dice[n][2] == dice[m][2]
&& dice[n][3] == dice[m][3]
&& dice[n][4] == dice[m][4]
&& dice[n][5] == dice[m][5])
{
printf("No\n");
return 0;
}
}
}
i = 4;
}
}
printf("Yes\n");
return 0;
} | 0 |
#include <bits/stdc++.h>
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;
}
typedef long long int ll;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define endl "\n"
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
const double PI = acos(-1);
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b;
cin >> a >> b;
vector<string> g(100);
for(int i = 0; i < 100; i++) {
string tmp = "";
if(i < 50) {
for(int j = 0; j < 100; j++) {
tmp += "#";
}
} else {
for(int j = 0; j < 100; j++) {
tmp += ".";
}
}
g[i] = tmp;
}
int h = 0, w = 1;
while(a - 1 > 0) {
if(w == 99) {
h += 2;
w = 1;
}
g[h][w] = '.';
w += 2;
a--;
}
h = 51, w = 1;
while(b - 1 > 0) {
if(w == 99) {
h += 2;
w = 1;
}
g[h][w] = '#';
w += 2;
b--;
}
cout << "100 100" << endl;
for(int i = 0; i < 100; i++) {
cout << g[i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int N,Q;
string S;
cin >> N;
cin >> S;
cin >> Q;
vector<int> k(Q);
for (int i = 0; i < Q ; i++){
cin >> k.at(i);
}
for (int i = 0; i < Q ; i++){
long long dnum = 0,mnum = 0,dmnum = 0,ans = 0;
for (int j = 0 ; j < N ; j++){
if (j >= k.at(i)){
if (S.at(j-k.at(i)) == 'D'){
dnum -= 1;
dmnum -= mnum;
}else if (S.at(j-k.at(i)) == 'M'){
mnum -= 1;
}
}
if (S.at(j) == 'D'){
dnum += 1;
}else if (S.at(j) == 'M'){
mnum += 1;
dmnum += dnum;
}else if (S.at(j) == 'C'){
ans += dmnum;
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#include<math.h>
#include<algorithm>
#define rep(i,n) for (int i = 0; i < (n) ; ++i)
using namespace std;
using ll = long long ;
using P = pair<int, int> ;
#define PI 3.14159265358979323846264338327950
#define INF 1e18
int main() {
int n, l ;
cin >> n >> l ;
vector<int> vec (n) ;
rep(i, n) vec[i] = i + 1 ;
rep(i , n){
vec[i] = vec[i] + l - 1 ;
}
int t = 200000 ;
int num ;
rep(i, n){
if(t > abs(vec[i])){
t = abs(vec[i]) ;
num = i ;
}
}
int tot = 0;
rep(i, n){
if(i == num){
continue ;
}
else {
tot += vec[i] ;
}
}
cout << tot << endl ;
} | #include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/range/irange.hpp>
#include <boost/range/adaptor/indexed.hpp>
#define FOR(i,k,n) for(int i = (k);i < (n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(x) begin(x),end(x)
using namespace std;
using namespace boost::adaptors;
using namespace std::string_literals;
using ll = int64_t;
using vecint = vector<int>;
using vecll = vector<ll>;
using boost::irange;
ll fact[7000];
ll ifact[7000];
// a^-1 mod p
ll inv(ll a,ll p){
return ( a == 1 ? 1 : (1 - p*inv(p%a,a)) / a + p );
}
ll comb(ll n, ll k, ll m) {
return fact[n] * ifact[k] % m * ifact[n-k] % m;
}
ll pmod(ll x, ll i, ll m) {
if (i == 0) return 1;
if (i % 2 == 1) return pmod(x, i-1, m) * x % m;
ll h = pmod(x, i/2, m);
return h * h % m;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n,m;
cin>>n>>m;
fact[0] = 1;
REP(i,7000-1) {
fact[i+1] = (i+1) * fact[i] % m;
}
ifact[6999] = inv(fact[6999], m);
REP(i,7000-1) {
int j = 7000-i-1;
ifact[j-1] = j * ifact[j] % m;
}
ll inv3 = inv(3, m);
ll inv2 = inv(2, m);
ll ans = 0;
REP(i,n+1) {
REP(j,n+1-i) {
ll tmp = comb(3*n, 3*i, m);
tmp *= fact[3*i] * ifact[i] % m;
tmp %= m;
tmp *= pmod(inv3, i, m);
tmp %= m;
ll rem = 3*n - 3*i;
tmp *= comb(rem, 2*j, m);
tmp %= m;
tmp *= fact[2*j] * ifact[j] % m;
tmp %= m;
tmp *= pmod(inv2, j, m);
tmp %= m;
ans += tmp;
ans %= m;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
void read(int &x) {
char ch; bool ok;
for(ok=0,ch=getchar(); !isdigit(ch); ch=getchar()) if(ch=='-') ok=1;
for(x=0; isdigit(ch); x=x*10+ch-'0',ch=getchar()); if(ok) x=-x;
}
#define rg register
const int maxn=1e5+10;bool vis[maxn];
int n,k,dep[maxn],ans,f[maxn],cnt,pre[maxn*2],nxt[maxn*2],h[maxn];
void add(int x,int y){
pre[++cnt]=y,nxt[cnt]=h[x],h[x]=cnt;
}
void dfs(int x){
vis[x]=1;
for(rg int i=h[x];i;i=nxt[i])
if(!vis[pre[i]])dfs(pre[i]),dep[x]=max(dep[pre[i]]+1,dep[x]);
if(dep[x]>=k-1&&f[x]!=1)dep[x]=-1,ans++;
}
int main()
{
read(n),read(k);scanf("%d",&f[1]);
for(rg int i=2;i<=n;i++)read(f[i]),add(f[i],i);
if(f[1]!=1)ans++,f[1]=1;dfs(1);
printf("%d\n",ans);
} | #include <iostream>
#include <string>
#include <utility>
#include <stack>
#include <vector>
#include <queue>
#include <algorithm>
#include <map>
#include <climits>
#include <set>
#include <cmath>
#include <numeric>
using namespace std;
int a[100000];
vector <int> children[100000];
int d[100000];
bool done[100000];
void set_d(int cur, int cur_d){
d[cur] = cur_d;
for(int i = 0; i < children[cur].size(); i++){
set_d(children[cur][i], cur_d + 1);
}
}
void set_done(int cur){
if(done[cur]){
return;
}
done[cur] = true;
for(int i = 0; i < children[cur].size(); i++){
set_done(children[cur][i]);
}
}
int main(){
int N;
long long K;
cin >> N >> K;
for(int i = 0; i < N; i++){
cin >> a[i];
a[i] --;
if(i != 0){
children[a[i]].push_back(i);
}
}
for(int i = 0; i < N; i++){
d[i] = INT_MAX;
}
set_d(0, 0);
int ans;
if(a[0] == 0){
ans = 0;
} else {
ans = 1;
}
vector <pair <int, int> > tmp;
for(int i = 0; i < N; i++){
if(d[i] <= K){
//done[i] = true;
} else {
tmp.push_back(make_pair(d[i], i));
}
}
sort(tmp.begin(), tmp.end());
reverse(tmp.begin(), tmp.end());
for(int i = 0; i < tmp.size(); i++){
int cur_d = tmp[i].first;
int cur = tmp[i].second;
if(!done[cur]){
int teleport = cur;
for(int i = 0; i < K - 1; i++){
teleport = a[teleport];
}
ans ++;
set_done(teleport);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define INF 10000000000
#define MOD 1000000007
using ll = long long;
using Graph = vector<vector<int>>;
int main(){
int N,T; cin>>N>>T;
vector<pair<int,int>> AB;
rep(i,N){
int a,b; cin>>a>>b;
AB.push_back({a,b});
}
sort(AB.begin(),AB.end());
vector<vector<int>> dp(N+1,vector<int> (T+1,0));
for(int i = 0; i < N; i++){
for(int t = 0; t < T; t++){
int a = AB.at(i).first;
int b = AB.at(i).second;
if(a+t>T)dp.at(i+1).at(T) = max(dp.at(i+1).at(T),dp.at(i).at(t)+b);
if(a>t)dp.at(i+1).at(t) = dp.at(i).at(t);
else{
dp.at(i+1).at(t) = max(dp.at(i).at(t),dp.at(i).at(t-a)+b);
}
}
}
int res = 0;
rep(i,N+1)res = max({res,dp.at(i).at(T-1),dp.at(i).at(T)});
cout<<res<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
int K, T;
cin >> K >> T;
priority_queue<pair<int, int>> q;
int ai;
for (int i = 0; i < T; i++)
{
cin >> ai;
q.push(make_pair(ai, i + 1));
}
int res = 0;
int prev = 0;
for (int i = 0; i < K; i++)
{
pair<int, int> p0 = q.top();
q.pop();
if (p0.second == prev)
{
if (q.empty())
{
res += p0.first;
break;
}
else
{
pair<int, int> p1 = q.top();
q.pop();
p1.first--;
prev = p1.second;
if (p1.first > 0)
{
q.push(p1);
}
}
}
else
{
p0.first--;
prev = p0.second;
}
if (p0.first > 0)
{
q.push(p0);
}
}
cout << res << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N);
for(int i=0; i<N ;i++){
cin >> A.at(i);
}
sort(A.begin(),A.end());
int x=0;
for(int i=0; i<N-1 ; i++){
if(A.at(i)==A.at(i+1)){
cout << "NO" << endl;
x=1;
break;
}
}
if(x==0){
cout << "YES" << endl;
}
}
| #include <bits/stdc++.h>
#define REP(i, n) for(ll i = 0; i < (ll)(n); i++)
#define FOR(i, a, b) for(ll i = a; i < (ll)(b); i++)
#define ALL(x) x.begin(), x.end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define SORT(x) sort(ALL(x))
#define REV(x) reverse(ALL(x))
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using vs = vector<string>;
using vb = vector<bool>;
using sl = stack<ll>;
using ql = queue<ll>;
const long long INF=2305843009213693951;
const long long dx[]={0,1,0,-1,1,-1,1,-1};
const long long dy[]={1,0,-1,0,1,1,-1,-1};
void Yes(bool a){cout<<(a?"Yes":"No")<<endl;}
void YES(bool a){cout<<(a?"YES":"NO")<<endl;}
int binary_search(ll x, vl a){
auto ite = lower_bound(ALL(a), x);
if(ite != a.end() && *ite == x) {
return ite - a.begin() ;
} else {
return -1;
}
}
ll modpow(ll a, ll n, ll mod) {
if(n == 0)
return 1;
if(n == 1)
return a % mod;
if(n % 2 == 1)
return (a * modpow(a, n - 1, mod)) % mod;
ll t = modpow(a, n / 2, mod);
return (t * t) % mod;
}
int main() {
ll N;
bool ans = true;
cin >> N;
vb check(1000000002, false);
REP(i, N){
ll A;
cin >> A;
if(check[A] == false){
check[A] = true;
} else {
ans = false;
break;
}
}
YES(ans);
return 0;
} | 1 |
#include<stdio.h>
int main() {
char ktae1[106];
char ktae2[108];
scanf("%s %s", &ktae1, &ktae2);
printf("%s%s", ktae2, ktae1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
long N;
cin >> N;
N--;
string name = "";
char digit = 'a';
while (N >= 0) {
if (N % 26 != 0) {
digit = 'a' + N % 26;
} else {
digit = 'a';
}
name = digit + name;
N = N / 26 - 1;
}
cout << name << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = (0); i < (n); ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define DEBUG(val) cout << #val << " : " << val << endl
#define MOD 1000000007
int main() {
int k, t;
cin >> k >> t;
int ans = 0;
int prev = -1;
priority_queue<pair<int, int>> data;
REP(i, t) {
int x;
cin >> x;
pair<int, int> p = make_pair(x, i + 1);
data.push(p);
}
while (!data.empty()) {
pair<int, int> p1 = data.top();
data.pop();
if (data.empty()) {
ans += (p1.first - 1);
break;
}
pair<int, int> p2 = data.top();
data.pop();
if (p1.first != 1) {
pair<int, int> p = make_pair(p1.first - 1, p1.second);
data.push(p);
}
if (p2.first != 1) {
pair<int, int> p = make_pair(p2.first - 1, p2.second);
data.push(p);
}
}
cout << ans << endl;
} | #include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<queue>
#include<cmath>
#include<cstdlib>
#define LL long long
#define LD long double
using namespace std;
const int NN=200 +117;
const int MM=1 +117;
int read(){
int fl=1,x;char c;
for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
if(c=='-'){fl=-1;c=getchar();}
for(x=0;c>='0'&&c<='9';c=getchar())
x=(x<<3)+(x<<1)+c-'0';
return x*fl;
}
void open(){
freopen("a.in","r",stdin);
//freopen("a.out","w",stdout);
}
void close(){
fclose(stdin);
fclose(stdout);
}
int m,n;
int a[2*NN][2*NN]={};
bool vis[2*NN][2*NN]={};
int stat[4]={};
int pp[3][2*NN][2]={};
int cnt[3];
int pre[4][2]={{1,1},{1,-1},{-1,1},{-1,-1}};
bool inside(int x,int y){
return x>=0&&x<2*n&&y>=0&&y<2*n;
}
void col(int x,int y,int c,int now){
vis[x][y]=1;
if(now)a[x][y]^=c;
for(int i=1;i<=cnt[c];++i){
for(int j=0;j<4;++j){
int nx=x+pre[j][0]*pp[c][i][0];
int ny=y+pre[j][1]*pp[c][i][1];
if(inside(nx,ny)&&!vis[nx][ny]){
col(nx,ny,c,now^1);
}
}
}
}
int main(){
//open();
n=read();
int d1=read(),d2=read();
for(int i=0;i<=2*n;++i){
int tp=d1-i*i;
int k=tp>0?sqrt(tp)+0.1:0;
if(i*i<=d1&&k*k==tp){
pp[1][++cnt[1]][0]=i;
pp[1][cnt[1]][1]=k;
}
tp=d2-i*i;
k=tp>0?sqrt(tp)+0.1:0;
if(i*i<=d2&&k*k==tp){
pp[2][++cnt[2]][0]=i;
pp[2][cnt[2]][1]=k;
}
}
for(int i=0;i<2*n;++i){
for(int j=0;j<2*n;++j){
if(!vis[i][j])col(i,j,1,1);
}
}
for(int i=0;i<2*n;++i){
for(int j=0;j<2*n;++j){
vis[i][j]=0;
}
}
for(int i=0;i<2*n;++i){
for(int j=0;j<2*n;++j){
if(!vis[i][j])col(i,j,2,1);
}
}
for(int i=0;i<2*n;++i){
for(int j=0;j<2*n;++j){
++stat[a[i][j]];
}
}
int mx=0;
for(int i=0;i<4;++i)if(stat[i]>stat[mx])mx=i;
int opcnt=0;
for(int i=0;i<2*n;++i){
for(int j=0;j<2*n;++j){
if(opcnt<n*n&&a[i][j]==mx){
printf("%d %d\n",i,j);
++opcnt;
}
}
}
close();
return 0;
} | 0 |
#include<bits/stdc++.h>
#define ll long long
#define mp make_pair
#define F first
#define S second
#define db double
#define pb push_back
#define rep(i,a,b) for(ll i=a;i<=b;i++)
using namespace std;
ll mod=1e9 +7;
ll expo(ll base,ll exponent,ll mod){
ll ans=1;
while(exponent!=0){
if(exponent&1) ans=(1LL*ans*base)%mod;
base=(1LL*base*base)%mod;
exponent>>=1;
}
return ans%mod;
}
vector<bool> prime(90000002,true);
void Sieve()
{
for (int p=2; p*p<=90000001; p++)
{
// If prime[p] is not changed, then it is a prime
if (prime[p] == true)
{
for (int i=p*p; i<=90000001; i += p)
prime[i] = false;
}
}
}
const ll M=200006;
ll f[M],inv[M];
void compute(){
f[0]=1;
rep(i,1,M-1){
f[i]=(1LL*i*f[i-1])%mod;
}
inv[M-1]=expo(f[M-1],mod-2,mod);
for(ll i=M-2;i>=0;i--){
inv[i]=(1LL*(i+1)*inv[i+1])%mod;
}
}
ll C(ll n,ll r){
return (1LL*((1LL*f[n]*inv[r])%mod)*inv[n-r])%mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// compute();
// Sieve();
ll tests=1;
// cin>>tests;
while(tests--)
{
ll i,j,k,n;
string s;
cin>>n;
cin>>s;
// cout<<s<<"\n";
vector<ll>r(n+1,0),g(n+1,0),b(n+1,0);
for(i=n-1;i>=0;i--)
{
r[i]+=r[i+1];
g[i]+=g[i+1];
b[i]+=b[i+1];
if(s[i]=='R') r[i]++;
else if(s[i]=='G') g[i]++;
else b[i]++;
}
// cout<<g[0]<<"\n";
ll ans=0;
rep(i,0,n-1)
{
rep(j,i+1,n-1)
{
if(s[i]==s[j]) continue;
if((s[i]=='R' && s[j]=='G') || (s[i]=='G' && s[j]=='R'))
{
ans+=b[j+1];
if(j+(j-i)<n && s[j+(j-i)]=='B') ans--;
}
else if((s[i]=='R' && s[j]=='B') || (s[i]=='B' && s[j]=='R'))
{
ans+=g[j+1];
if(j+(j-i)<n && s[j+(j-i)]=='G') ans--;
}
else
{
ans+=r[j+1];
if(j+(j-i)<n && s[j+(j-i)]=='R') ans--;
}
}
// cout<<"--"<<ans<<"\n";
}
cout<<ans;
}
return 0;
} | #include <iostream>
#include <vector>
#include <array>
#include <list>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <string>
#include <sstream>
#include <algorithm>
#include <random>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <cassert>
#include <climits>
#include <bitset>
#include <functional>
#define FOR_LT(i, beg, end) for (int i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (int i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (int i = beg; end <= i; i--)
using namespace std;
int64_t kRem = 1000000007;
int64_t factorial_rem(int n, int64_t rem)
{
if (n == 0) return 0;
int64_t ans = 1;
FOR_LE(i, 1, n) {
ans *= i;
ans %= rem;
}
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n; cin >> n;
string s; cin >> s;
int64_t c = 0;
int64_t ans = 1;
FOR_LT(i, 0, 2 * n) {
int cc = c;
if (s[i] == 'B') {
cc++;
}
if (cc & 1) c++;
else {
ans *= c;
ans %= kRem;
c--;
}
}
if (c != 0) {
cout << 0 << endl;
return 0;
}
ans *= factorial_rem(n, kRem);
ans %= kRem;
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
ios::sync_with_stdio(false);
cin.tie(0);
int e;
while(cin >> e, e){
int x, y, z;
int ans = INT_MAX;
for(z = 0; z*z*z <= e; z++){
y = sqrt(e-pow(z, 3));
x = e - pow(z, 3) - pow(y,2);
ans = min(ans, x+y+z);
}
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
template<class T> void operator>> (istream& ist, vector<T>& vs) { for(auto& e: vs) cin >> e; }
typedef long long ll;
int const inf = 1<<29;
int main() {
int M, N[2];
for(; cin >> M >> N[0] >> N[1] && M;) {
vector<int> vs(M); cin >> vs;
int maxgap = 0;
int maxnum = -1;
REP(num, N[0], N[1] + 1) {
if(maxgap <= vs[num - 1] - vs[num]) {
maxgap = vs[num - 1] - vs[num];
maxnum = num;
}
}
cout << maxnum << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <set>
using namespace std;
int main(void){
int n,m;
while(cin>>n>>m,n||m){
vector<set<int> > friends(n+1);
for(int i=0,a,b;i<m;++i){
cin>>a>>b;
friends[a].insert(b);friends[b].insert(a);
}
set<int> myfriends;
for(set<int>::iterator it=friends[1].begin();it!=friends[1].end();++it){
for(set<int>::iterator it2=friends[*it].begin();it2!=friends[*it].end();++it2){
myfriends.insert(*it2);
}
myfriends.insert(*it);
}
int ans=((myfriends.find(1)!=myfriends.end())?myfriends.size()-1:myfriends.size());
cout<<ans<<endl;
}
return 0;
} | #include<iostream>
using namespace std;
int main(){
int n,p;
while(1){
cin>>n>>p;
if(n+p==0) break;
int a[50]={},s=p;
int i=0,vic,f=0;
while(1){
if(i==n) i=0;
if(f==1) break;
if(p<=0){
if(a[i]==s){
f=1;
vic=i;
}
if(p==0){
p+=a[i];
a[i]=0;
}
}
else{
a[i]++;
p--;
}
i++;
}
cout<<vic<<endl;
}
return 0;
} | 0 |
//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <stdexcept>
using namespace std;
// type alias
using ll = long long;
using ull = unsigned long long;
//conversion
//------------------------------------------
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }
//debug
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) cerr << #x << " = " << (x) << " (l" << __line__ << ")" << " " << __file__ << endl
inline ll floor(ll a, ull b)
{
ll llb = b;
if (a >= 0)
{
return a / llb;
}
else
{
return - ( (-a + llb - 1) / llb);
}
}
inline ll ceil(ll a, ull b)
{
ll llb = b;
if (a >= 0)
{
return (a + llb - 1) / llb;
}
else
{
return - (-a / llb);
}
}
inline ll getLowestOneBit(ll a)
{
return a & (-a);
}
inline ll getHighestOneBit(ll a)
{
while ((a & (a - 1)) != 0)
{
a = a & (a - 1);
}
return a;
}
inline bool isPower2(ull a)
{
if (a == 0)
{
return false;
}
return !(a & (a - 1));
}
inline ll getSpecifiedBit(ll a, unsigned bit)
{
return (a & (1LL << bit)) >> bit;
}
// computational complexity: o(log(max(a, b)))
inline ull getGcd(ull a, ull b)
{
if (b == 0)
{
return a;
}
return getGcd(b, a % b);
}
template<class Integer>
inline Integer getPower(Integer base, ull exponential)
{
Integer result = 1;
while (exponential >= 1)
{
if (exponential & 1)
{
result = result * base;
}
base = base * base;
exponential >>= 1;
}
return result;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<vector<ll>> As(N, vector<ll>(60));
vector<ll> bit_count(60);
ll a;
for (ll i = 0; i < N; ++i)
{
cin >> a;
for (ll j = 0; j < 60; ++j)
{
As[i][j] = (a & (1LL << j)) >> j;
bit_count[j] += (a & (1LL << j)) >> j;
}
}
ll res = 0;
for (ll j = 0; j < 60; ++j)
{
if (bit_count[j] % 2 != 0)
{
res += 1LL << j;
for (ll i = 0; i < N; ++i)
{
As[i][j] = 0;
}
}
}
ll row = 0;
for (ll j = 59; j >= 0; --j)
{
if (bit_count[j] % 2 != 0) continue;
for (ll i = row; i < N; ++i)
{
if (As[i][j] == 0) continue;
vector<ll> temp = As[row];
As[row] = As[i];
As[i] = temp;
for (ll k = row + 1; k < N; ++k)
{
if (As[k][j] == 0) continue;
for (ll l = 0; l < 60; ++l)
{
As[k][l] = (As[k][l] - As[row][l] + 2LL) % 2LL;
}
}
++row;
break;
}
}
vector<ll> f2_vec(60);
row = 0;
for (ll j = 59; j >= 0; --j)
{
if (As[row][j] == 0) continue;
if (f2_vec[j] == 0)
{
for (ll k = 0; k < 60; ++k)
{
f2_vec[k] = (f2_vec[k] + As[row][k] + 2LL) % 2;
}
}
++row;
}
for (ll j = 0; j < 60; ++j)
{
if (f2_vec[j] == 1)
{
res += (1LL << j) * 2;
}
}
cout << res << endl;
return 0;
}
| #include <iostream>
#include <vector>
int main() {
int N;
std::cin >> N;
std::vector<long long> A(N);
for (int i = 0; i < N; i++) std::cin >> A[i];
long long xor_A = 0;
for (int i = 0; i < N; i++) xor_A ^= A[i];
std::vector<long long> v(N);
for (int i = 0; i < N; i++) v[i] = A[i] & ~xor_A;
long long rank = 0;
for (int i = 59; i >= 0; i--) {
for (int j = rank; j < N; j++) {
if (v[j] & 1LL << i) {
if (j > rank) v[rank] ^= v[j];
for (int k = 0; k < N; k++) {
if (k != rank && v[k] & 1LL << i)
v[k] ^= v[rank];
}
rank++;
break;
}
}
}
long long res = 0;
for (int i = 0; i < N; i++) res ^= v[i];
std::cout << res * 2 + xor_A << "\n";
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<lint> vlint;
#define inf 1e+9
#define endl "\n"
#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 rep_rev(i, n) for (int i = n-1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define Size(c) (int)(c).size()
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
template <class T, class S> inline bool chmax(T &a, S b) {
if(a < b) {a = b;return 1;} return 0;
}
template <class T, class S> inline bool chmin(T &a, S b) {
if(a > b) {a = b;return 1;} return 0;
}
template <class T>
void line(vector<T> &x){for (auto&& xi : x) cin >> xi;}
inline void IN(void){ return;}
template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){ cin >> first; IN(rest...); return;}
#define INT(...) int __VA_ARGS__; IN (__VA_ARGS__)
#define LINT(...) lint __VA_ARGS__; IN (__VA_ARGS__)
#define STR(...) string __VA_ARGS__; IN(__VA_ARGS__)
template <class T> void UNIQUE(vector<T> &x) {
sort(all(x)); x.erase(unique(all(x)), x.end());
}
template <class T> void print_vec(T first, T end){
for (auto i = first; i < end - 1; i++) cout << *i << " ";
cout << *(end-1) << endl;
}
template<class... T>
void debug_print(T... args){
vector<lint> tmp = initializer_list<lint>{args...};
print_vec(all(tmp));
}
template<class T>
void print(T a){ cout << a << endl;}
vector<string> Yes = {"No", "Yes"};
vector<string> YES = {"NO", "YES"};
int ord(char x){ return (int)(x - 'a');}
char chr(lint x){ return (char)(x + (lint)('a'));}
lint mod = 1e9+7;
// lint mod =
lint sum(vlint a){lint ret = 0; for(auto&& v:a) ret += v; return ret;}
lint vmini(vlint a, lint &index){
lint ret = LLONG_MAX;
rep(i, Size(a)){ if (chmin(ret, a[i])) index = i;}
return ret;
}
lint vmaxi(vlint a, lint &index){
lint ret = -LLONG_MAX;
rep(i, Size(a)){ if (chmax(ret, a[i])) index = i;}
return ret;
}
lint vmin(vlint a){
lint ret = LLONG_MAX; for (auto && v : a) chmin(ret, v); return ret;
}
lint vmax(vlint a){
lint ret = -LLONG_MAX; for (auto && v : a) chmax(ret, v); return ret;
}
int main(){
INT(n, m);
vector<vlint> ans;
vlint check(n+1, 0); int cnt = 1; int diff = n-1;
while (cnt < cnt + diff){
ans.pb({cnt, cnt + diff});
cnt++;
diff -= 2;
if (n % 2 == 0 && diff+2 > n/2 && diff <= n/2) diff--;
}
rep(i, m){
print_vec(all(ans[i]));
}
}
| #include <bits/stdc++.h>
#define ALL(A) (A).begin(), (A).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); i++)
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; }
int dx[] = { 0, 1, -1, 0, 1, -1, 1, -1 }; // i<4:4way i<8:8way
int dy[] = { 1, 0, 0, -1, 1, -1, -1, 1 };
const ll mod = 1e9 + 7;
const ll INF = -1 * ((1LL << 63) + 1);
const int inf = -1 * ((1 << 31) + 1);
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n,m;
cin >> n >> m;
if(m==1){
cout << "1 2" << endl;
return 0;
}
int i1 = 1;
int i2 = m + 2;
for(int diff = m;diff >= 1;diff--){
cout << i1 << " " << i1 + diff << endl;
i1++;
swap(i1,i2);
}
}
| 1 |
#include <iostream>
#include <vector>
#include<list>
#include <algorithm>
#include <string>
#include <math.h>
#include<map>
#include <utility>
#include<queue>
using namespace std;
#define REP(i,k,n) for(int i=k;i<n;i++)
#define INF 1844674407370955161
typedef long long unsigned int ll;
#define SIZE_OF_ARRAY(array) (sizeof(array)/sizeof(array[0]))
#define MOD 1000000007
template<typename T>
int vector_finder(std::vector<T> vec, T number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance( vec.begin(), itr );
if (index != vec.size()) { // 発見できたとき
return 1;
}
else { // 発見できなかったとき
return 0;
}
}
template<typename T>
T gcd(T a,T b){
if(b>0){
return gcd(b, a % b);
}else{
return a;
}
}
template<typename T>
T lcm(T a,T b){
T g = gcd(a, b);
return a * b / g;
}
void clear( std::queue<pair<int,int> > &q )
{
std::queue<pair<int,int> > empty;
std::swap( q, empty );
}
bool IsPrime(int num)
{
if (num < 2) return false;
else 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;
}
template<typename T>
std::vector<T> enum_div(T n)//nの約数を列挙
{
std::vector<T> ret;
for(T i=1 ; i*i<=n ; ++i)
{
if(n%i == 0)
{
ret.push_back(i);
if(i!=1 && i*i!=n)
{
ret.push_back(n/i);
}
}
}
return ret;
}
int main()
{
int n, m;
long long xans=0;
long long yans = 0;
cin >> n >> m;
REP(i,1,n+1){
long long x;
cin >> x;
xans += (2 * i - n - 1) * x;
}
REP(i,1,m+1){
long long y;
cin >> y;
yans += (2 * i - m - 1) * y;
}
xans %= MOD;
yans %= MOD;
ll ans = xans * yans % MOD;
cout << ans << endl;
return 0;
} | //thuanqvbn03
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
const int Mod = 1000000007;
int n, D;
string s;
long long dp[MaxN], tmp[MaxN];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
cin >> D;
n = s.size();
for (int i = s[0] - '0' - 1; i >= 0; i--)
{
dp[i % D]++;
}
int Sums = (s[0] - '0') % D;
for (int i = 1; i < n; i++)
{
int x = s[i] - '0';
for (int k = 0; k < D; k++)
{
tmp[k] = tmp[k] + dp[k];
tmp[k + 10] = tmp[k + 10] - dp[k] + Mod;
}
tmp[Sums]++;
tmp[Sums + x]--;
Sums = (Sums + x) % D;
dp[0] = tmp[0];
tmp[0] = 0;
for (int k = 1; k < D + 10; k++)
{
dp[k] = (tmp[k] + dp[k - 1]) % Mod;
tmp[k] = 0;
}
for (int k = D; k < D + 10; k++)
{
dp[k % D] = (dp[k % D] + dp[k]) % Mod;
}
}
long long ans = (dp[0] + (Sums % D == 0) - 1 + Mod) % Mod;
cout << ans;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iomanip>
#include<string>
using namespace std;
int main(){
long long int k,x,a;
cin>>k>>x;
for(int i=1;i<=(2*k-1);i++)
{a=x-k+i;
cout<<a<<" ";
}
cout<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fastIO ios::sync_with_stdio(0), cin.tie(0)
#define endl '\n'
#define ft first
#define sd second
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<char,char> pcc;
typedef pair<long long,long long> pll;
int main() {
fastIO;
int x, k;
cin >> k >> x;
for(int i = x-k+1; i <= x+k-1; i++){
if(i != x+k-1) cout << i << " ";
else cout << i << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct rev_vector {
const int magic = 123456;
vector<int> pk;
int l, r;
rev_vector(){
pk.resize(3 * magic);
l = magic;
r = l;
}
void shift_right(){
l--;
pk[l] = 0;
}
int& operator [](int pos){
while(pos + l <= r) pk[r++] = 0;
return pk[pos + l];
}
void clear(){
l = magic;
r = l;
}
};
const int maxn = 100100;
int ans, k, vis[maxn];
vector<int> e[maxn];
int dfs(int u){
int dep = 0;
for(int v : e[u]) {
int mv = dfs(v);
if(mv == k - 1 && u){
ans++;
} else {
dep = max(dep, mv + 1);
}
}
return dep;
}
int main(){
int n; cin >> n >> k;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i], a[i]--;
if(a[0] != 0){
a[0] = 0;
ans++;
}
for(int i = 0; i < n; i++){
if(i != a[i]){
e[a[i]].push_back(i);
}
}
dfs(0);
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <sstream>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#define rep(i, n) for(int i = 0; i < n; i ++)
#define COUNT(i, n) for(int i = 1; i <= n; i ++)
#define ITER(c) __typeof((c).begin())
#define each(c, it) for(ITER(c) it =(c).begin(); it!=(c).end(); it++)
#define ALL(c) c.begin(), c.end()
#define mp make_pair
#define pb push_back
#define MEMSET(v, h) memset((v), h, sizeof(v))
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
const int INF = 1 << 24;
int main(void){
for(int n, m, s; s = 0, cin >> n >> m, n; cout << s << endl){
priority_queue<int> p;
rep(i, n){
int in; cin >> in;
p.push(in);
}
COUNT(i, n){
if(i % m) s += p.top();
p.pop();
}
}
return 0;
} | 0 |
#include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
//ll mod = 998244353;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
string s;
cin >> s;
rep(i, 1<<3) {
int num = s[0] - '0';
string ans = "";
ans += s[0];
rep(j, 3) {
if ((i>>j) & 1) {
//cout << s[j+1] - '0' << endl;
num += (s[j+1] - '0');
ans += '+';
ans += s[j+1];
}
else {
//cout << s[j+1] - '0' << endl;
num -= (s[j+1] - '0');
ans += '-';
ans += s[j+1];
}
//cout << num << endl;
//cout << ans << endl;
}
if (num == 7) {
cout << ans << "=7" << endl;
return 0;
}
}
return 0;
}
| #include<bits/stdc++.h>
#define all(v) v.begin(),v.end()
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,a,b=0;
cin>>n;
a=n;
while(a>0){
b+=a%10;
a/=10;
}
if(n%b==0)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return(0);
} | 0 |
#include <bits/stdc++.h>
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n;i>=a;i--)
#define vi vector<int>
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
#define mod(x) ((x)%MOD)
#define o(X) (1<<(X))
#define oL(X) (1LL<<(X))
#define LL long long
#define ppt(x) __builtin_popcount(x)
using namespace std;
const int INF=0x3f3f3f3f,N=1e6+5,MOD=1e9+7;
const LL INF_LL=0x3f3f3f3f3f3f3f3fLL;
template<typename T>
inline int getplc(T x,int y) { return (x>>y)&1; }
template<typename T>
T square(T x) {return x*x;}
LL qpow(LL a,LL b=MOD-2,LL _MOD=MOD){
LL res=1;
for(;b;b>>=1,a=a*a%_MOD){
if(b&1)res=res*a%_MOD;
}
return res;
}
template <typename T>
T Smax(T x) { return x; }
template<typename T, typename... Args>
T Smax(T a, Args... args) {
return max(a, Smax(args...));
}
template <typename T>
T Smin(T x) { return x; }
template<typename T, typename... Args>
T Smin(T a, Args... args) {
return min(a, Smin(args...));
}
template <typename T>
#define errorl(args...) { \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
errl(_it, args); \
}
void errl(istream_iterator<string> it) {}
template<typename T, typename... Args>
void errl(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
errl(++it, args...);
}
#define error(args...) { \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
cerr<<endl; \
}
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << "=" << a << " # ";
err(++it, args...);
}
LL a[N],b[N];
int add(LL x){
for(int i=60;i>=0;i--){
if(getplc(x,i)){
if(!a[i]){
a[i]=x;
return 1;
}
else x^=a[i];
}
}
return 0;
}
char s[N];
void Solve(){
int cas;
for(cin>>cas;cas--;){
int n;
cin>>n;
rep(i,1,n){
cin>>b[i];
}
cin>>s+1;
int ans=0;
per(i,1,n){
if(add(b[i])&&s[i]=='1'){
ans=1;
break;
}
}
cout<<ans<<'\n';
for(int i=0;i<=60;i++)a[i]=0;
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
// freopen("o1.txt","w",stdout);
#endif
ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);
Solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
class BinaryIndexedTree {
private:
int n;
vector<int64> xs;
public:
BinaryIndexedTree(int n) : n(n), xs(n) {}
// Adds x to the i-th element.
void Add(int i, int64 x) {
int cur = i;
while (cur < n) {
xs[cur] += x;
cur = cur | (cur + 1);
}
}
// Returns a sum of a range [l r).
int64 SumOfRange(int l, int r) {
if (l >= r) return 0;
if (l > 0) {
return SumOfRange(0, r) - SumOfRange(0, l);
}
int64 s = 0;
int i = r - 1;
while (i >= 0) {
s += xs[i];
i = (i & (i + 1)) - 1;
}
return s;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
BinaryIndexedTree bit(n);
vector<int64> xs(n);
for (int i = 0; i < n; i++) {
cin >> xs[i];
}
for (int i = 0; i < n; i++) {
bit.Add(i, xs[i]);
}
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 0) {
int p, x;
cin >> p >> x;
bit.Add(p, x);
} else {
int l, r;
cin >> l >> r;
cout << bit.SumOfRange(l, r) << "\n";
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define int long long
typedef long long ll;
int color[200000];
int n,m;
vector<vector<int>> v(200000);
/*
bool dfs(int nn, int pre, int c){
for(int x:v[nn]){
if(x==pre) continue;
if(color[x]==-1) color[x]=1-c;
//if(color[x]!=c) continue;
if(color[x]==c) return false;
if(!dfs(x,nn,color[x])) return false;
}
return true;
}*/
bool dfs(int vv,int c){
color[vv]=c;
for(auto x:v[vv]){
if(color[x]==c) return false;
if(color[x]==0 && !dfs(x,-c)) return false;
}
return true;
}
signed main(){
cin >> n >> m;
memset(color,0,sizeof(color));
rep(i,m){
int aa,bb;
cin >> aa >> bb;
v[aa-1].push_back(bb-1);
v[bb-1].push_back(aa-1);
}
//color[0]=0;
rep(i,n){
if(color[i]==0){
if(!dfs(i,1)){
cout << ((n*(n-1))/2)-m << endl;
return 0;
}
}
}
int white=0;
int black=0;
rep(i,n){
if(color[i]==1) white++;
else black++;
}
//cout << white << black << endl;
cout << white*black-m << endl;
} | #include <bits/stdc++.h>
using namespace std;
class UnionFind {
public:
std::vector<int> parent;
UnionFind(int n) : parent(n, -1) {}
int root(int x) {
if (parent[x] < 0) return x;
return parent[x] = root(parent[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
int size(int x) { return -parent[root(x)]; }
bool unite(int x, int y) {
int rx = root(x), ry = root(y);
if (rx == ry) return false;
if (parent[rx] > parent[ry]) std::swap(rx, ry);
parent[rx] += parent[ry];
parent[ry] = rx;
return true;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
UnionFind uf(2 * N);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--, b--;
uf.unite(a, b + N);
uf.unite(a + N, b);
}
if (uf.issame(0, N)) {
cout << 1LL * N * (N - 1) / 2 - M << '\n';
} else {
int cnt = 0;
for (int i = 0; i < N; i++) {
if (uf.issame(0, i)) cnt++;
}
// cout << cnt << '\n';
cout << 1LL * cnt * (N - cnt) - M << '\n';
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <climits>
#include <utility>
typedef long long ll;
using namespace std;
const ll MOD = 998244353LL;
const ll MAX = 2000010LL;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll modpow(ll a, ll n) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
int main(int argc, char *argv[]) {
COMinit();
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0LL;
for(ll i=0;i<=k;i++){
ans += ((m*modpow(m-1LL,n-i-1LL)%MOD)*COM(n-1LL,i)) % MOD;
ans %= MOD;
}
if(ans<0LL){
ans += MOD;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define loop(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < n; ++i)
#define dump(a) cerr << #a << " = " << (a) << "(L:" << __LINE__ << ")" << endl
const long long MOD = 998244353;
const int FACT_MAX = 1000000;
long long fact[FACT_MAX];
long long inv[FACT_MAX];
long long invfact[FACT_MAX];
long long nPr(int n, int r) { return (fact[n] * invfact[n - r]) % MOD; }
long long nCr(int n, int r) {
return (((fact[n] * invfact[r]) % MOD) * invfact[n - r]) % MOD;
}
void initialize_fact() {
fact[0] = 1;
inv[0] = 0;
inv[1] = 1;
invfact[0] = 1;
loop(i, 1, FACT_MAX) fact[i] = (i * fact[i - 1]) % MOD;
loop(i, 2, FACT_MAX) inv[i] = MOD - ((MOD / i) * inv[MOD % i] % MOD);
loop(i, 1, FACT_MAX) invfact[i] = (invfact[i - 1] * inv[i]) % MOD;
}
void solve(long long N, long long M, long long K) {
initialize_fact();
vector<long long> pow_m(N + 1);
pow_m[0] = 1;
rep(i, N) pow_m[i + 1] = (pow_m[i] * (M-1)) % MOD;
long long ans = 0;
rep (k, K + 1) {
long long cmb = M;
cmb *= nCr(N-1, k);
cmb %= MOD;
cmb *= pow_m[N-1-k];
cmb %= MOD;
ans += cmb;
ans %= MOD;
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
long long K;
scanf("%lld", &K);
solve(N, M, K);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#ifdef Adrian
#include "debug.h"
#else
#define debug(...) 9999
#endif
typedef long long ll;
typedef long double ld;
typedef complex<ld> point;
#define F first
#define S second
#define ii pair<ll,ll>
template <typename G>
struct triple{G F, S, T;};
#define iii triple<int>
int main()
{
#ifdef Adrian
//freopen("test.txt", "r", stdin);
#else
ios_base::sync_with_stdio(0); cin.tie(0);cout.tie(0);
#endif
const ll mod = 998244353;
string s;
int h;
cin>>s>>h;
int n = 0;
for(auto &i:s)
n += (i == '1');
vector<int> v;
for(int i=0, j=0; i<s.size(); i=j)
{
for(; j<s.size() && s[j] == '1'; j++);
v.push_back(j - i);
++j;
}
int m = v.size();
vector<vector<ll>> cur(n + 1, vector<ll>(n + 1));
vector<vector<ll>> next(n + 1, vector<ll>(n + 1));
for(int i=0; i<=n; i++)
cur[i][0] = 1;
vector<vector<ll>> ac1(2 * n + 1, vector<ll>(n + 2));
vector<vector<ll>> ac2(n + 1, vector<ll>(n + 2));
for(int i=1; i<m; i++)
{
for(int j=0; j<=n; j++)
for(int k=0; k<=n; k++)
{
ac1[j + k][j + 1] = cur[j][k];
ac2[k][j + 1] = cur[j][k];
}
for(auto &j:ac1)
for(int k=1; k<j.size(); k++)
j[k] = (j[k] + j[k - 1]) % mod;
for(auto &j:ac2)
for(int k=1; k<j.size(); k++)
j[k] = (j[k] + j[k - 1]) % mod;
for(int j=0; j<=n; j++)
for(int k=0; k<=n; k++)
{
next[j][k] = ac1[j + k][min(n, j + min(v[i], k)) + 1] - ac1[j + k][j];
next[j][k] += ac2[k][j];
next[j][k] %= mod;
if(next[j][k] < 0)
next[j][k] += mod;
}
swap(next, cur);
}
ll ans = 0;
for(int i=0; i<=min(h, n); i++)
ans = (ans + cur[0][i]) % mod;
cout<<ans<<'\n';
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int H,W,Ans,top,stop[2010][2010];
bool g[2010][2010];
struct Point{
int x,y;
Point() {}
Point(int x,int y):x(x),y(y) {}
}P[2010];
int main()
{
#ifdef h10
freopen("F.in","r",stdin);
freopen("F.out","w",stdout);
#endif
int i,j;
char c;
scanf("%d%d",&H,&W);
for (i=1;i<=H;i++)
for (j=1;j<=W;j++)
{
c=getchar();
while (c!='.'&&c!='#') c=getchar();
g[i][j]=c=='#';
}
Ans=max(H,W);
for (i=1;i<=H;i++)
for (j=W;j>=2;j--)
g[i][j]^=g[i][j-1];
for (j=2;j<=W;j++)
{
int last[2];
last[0]=last[1]=H+1;
for (i=H;i>=1;i--)
{
stop[i][j]=last[g[i][j]^1];
last[g[i][j]]=i;
}
}
for (i=1;i<H;i++)
{
P[top=1]=Point(i,W+1);
for (j=W;j>=2;j--)
{
while (P[top].x>=stop[i][j])
{
Ans=max(Ans,(P[top].x-i)*(P[top-1].y-j));
top--;
}
P[++top]=Point(stop[i][j],j);
}
while (top)
Ans=max(Ans,(P[top].x-i)*(P[top-1].y-j)),top--;
}
printf("%d\n",Ans);
}
| 0 |
#include <cstdio>
#include <algorithm>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <string>
#include <string.h>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <map>
#include <set>
#include <iostream>
#include <sstream>
#include <numeric>
#include <cctype>
#include <bitset>
#include <cassert>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define gep(i,g,j) for(int i = g.head[j]; i != -1; i = g.e[i].next)
#define each(it,c) for(__typeof((c).begin()) it=(c).begin();it!=(c).end();it++)
#define rng(a) a.begin(),a.end()
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define pb push_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcount
#define uni(x) x.erase(unique(rng(x)),x.end())
#define snuke srand((unsigned)clock()+(unsigned)time(NULL));
#define df(x) int x = in()
#define dame { puts("No"); return 0;}
#define show(x) cout<<#x<<" = "<<x<<endl;
#define PQ(T) priority_queue<T,vector<T>,greater<T> >
using namespace std;
typedef long long int ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
inline int in() { int x; scanf("%d",&x); return x;}
inline void priv(vi a) { rep(i,sz(a)) printf("%d%c",a[i],i==sz(a)-1?'\n':' ');}
template<typename T>istream& operator>>(istream&i,vector<T>&v)
{rep(j,sz(v))i>>v[j];return i;}
template<typename T>string join(vector<T>&v)
{stringstream s;rep(i,sz(v))s<<' '<<v[i];return s.str().substr(1);}
template<typename T>ostream& operator<<(ostream&o,vector<T>&v)
{if(sz(v))o<<join(v);return o;}
template<typename T1,typename T2>istream& operator>>(istream&i,pair<T1,T2>&v)
{return i>>v.fi>>v.se;}
template<typename T1,typename T2>ostream& operator<<(ostream&o,pair<T1,T2>&v)
{return o<<v.fi<<","<<v.se;}
const int MX = 100005, INF = 1001001001;
const ll LINF = 1e18;
const double eps = 1e-10;
// Binary Indexed Tree
struct bit {
typedef int TT;
int n; vector<TT> d;
bit() {}
bit(int mx): n(mx), d(mx) {}
void add(int i, TT x=1) {
for (++i;i<n;i+=i&-i) d[i] += x;
}
TT sum(int i) {
TT x = 0;
for (++i;i;i-=i&-i) x += d[i];
return x;
}
};
//
int f(vi& s) {
int n = sz(s);
bit t(n+5);
ll res = 0;
rep(i,n) {
res += i-t.sum(s[i]);
t.add(s[i]);
}
return res&1;
}
int main() {
int n;
scanf("%d",&n);
vvi na(3, vi(n));
rep(i,3)rep(j,n) na[i][j] = in()-1;
vi a, b;
rep(i,n) {
int x = na[0][i]/3;
a.pb(x);
rep(j,3) if (na[j][i]/3 != x) dame;
if (na[1][i]%3 != 1) dame;
b.pb(na[0][i]%3/2);
}
rep(i,n) if ((a[i]&1) != (i&1)) dame;
vvi s(2);
vi cnt(2);
rep(i,n) {
s[i&1].pb(a[i]/2);
cnt[i&1] += b[i];
}
rep(i,2) {
cnt[i^1] += f(s[i]);
}
rep(i,2) if (cnt[i]&1) dame;
puts("Yes");
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
int n,t[2],a[5][maxn],to[maxn];
int main()
{
ios::sync_with_stdio(false);cin.tie(0);
cin>>n;
for(int i=1; i<=3; i++)
for(int j=1; j<=n; j++)
cin>>a[i][j];
for(int i=1; i<=n; i++)
{
to[i]=a[2][i]/3+1;
if(!((a[1][i]-a[2][i]==-1&&a[2][i]-a[3][i]==-1&&a[1][i]%3==1)||(a[1][i]-a[2][i]==1&&a[2][i]-a[3][i]==1&&!(a[1][i]%3)))||(abs(i-to[i])&1))
{
cout<<"No\n";
return 0;
}
if(a[1][i]>a[2][i])
t[i&1]^=1;
else t[i&1]^=0;
}
for(int i=1;i<=n;i++)
{
while(i!=to[i])
{
t[i&1^1]^=1;
swap(to[i],to[to[i]]);
}
}
if(t[0]||t[1]) cout<<"No\n";
else cout<<"Yes\n";
return 0;
}
| 1 |
#pragma GCC optimze("Ofast")
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define pp pair<ll,ll>
#define ppp pair<ll,pp >
#define trace(...) cout<<"Line:"<<__LINE__<<" "; __f(#__VA_ARGS__, __VA_ARGS__)
template<typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout<<name<<" : "<<arg1<<endl;
}
template<typename Arg1, typename ... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma=strchr(names+1,',');
cout.write(names,comma-names)<<" : "<<arg1<<" | ";
__f(comma+1,args...);
}
typedef tree<pp,null_type,less<pp>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define ld long double
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rep(i,a,b) for(ll i=a;i<b;i+=1)
#define sz(v) (ll)(v.size())
#define hell (ll)1000000007
#define slld(x) scanf("%lld",&x)
ll t=1, tt;
const ll inf=1e18;
inline ll mult(ll x,ll y){x%=hell;y%=hell;return (1LL*x*y)%hell;}
inline ll add(ll x,ll y){x+=y;return x%hell;}
inline ll powMod(ll base,ll expo){
if(base==0)return 0;
ll ans=1;
while(expo){
if(expo&1)ans=mult(ans,base);
base=mult(base,base);
expo>>=1;
}
return ans;
}
vector<ll> pre,dp;
void solve(){
ll n;
cin>>n;
vector<vector<ll> > a(n,vector<ll>(n));
rep(i,0,n)
rep(j,0,n)
cin>>a[i][j];
pre.resize(1<<n);
rep(mask,0,1LL<<n){
rep(i,0,n){
if((mask>>i)&1){
rep(j,i+1,n){
if((mask>>j)&1)pre[mask]+=a[i][j];
}
}
}
}
dp.resize(1<<n,-inf);
dp[0]=0;
rep(mask,0,1LL<<n){
vector<ll> not_taken;
rep(i,0,n)
if(!((mask>>i)&1))
not_taken.pb(i);
ll nn=sz(not_taken);
rep(mask2,0,1LL<<nn){
ll cur_mask=0;
rep(j,0,sz(not_taken))
if((mask2>>j)&1)cur_mask^=(1LL<<not_taken[j]);
dp[mask^cur_mask]=max(dp[mask^cur_mask],dp[mask]+pre[cur_mask]);
}
}
cout<<dp[(1<<n)-1];
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//cin>>t;
tt=t;
while(t--){
solve();
if(t)cout<<"\n";
}
return 0 ;
}
| #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int mod=998244353;
#define N 321
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,a[N],dp[N*N],sum,ans;
int main(){
n=read();
ans=1;
for(int i=1;i<=n;++i){
a[i]=read();
ans=3LL*ans%mod;
}
dp[0]=1;
for(int i=1;i<=n;++i){
sum+=a[i];
for(int j=sum;j>=0;--j){
(dp[j]<<=1)%=mod;
if(j>=a[i])dp[j]=(dp[j]+dp[j-a[i]])%mod;
}
}
for(int i=sum;sum-i<=i;--i){
ans=(ans-3LL*dp[i]%mod+mod)%mod;
}
if(!(sum&1)){
memset(dp,0,sizeof(dp));
dp[0]=1;
for(int i=1;i<=n;++i){
for(int j=sum;j>=a[i];--j){
dp[j]=(dp[j]+dp[j-a[i]])%mod;
}
}
ans=(ans+3LL*dp[sum>>1])%mod;
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define fast() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define test() ll t; cin>>t; while(t--)
#define lp0(i,begin,end) for(ll i=begin;i<end;i++)
#define lp1(i,begin,end) for(ll i=begin;i<=end;i++)
#define rlp(i,begin,end) for(ll i=end;i>=begin;i--)
#define prec(n) fixed<<setprecision(n)
#define initial(a,i) memset(a,i,sizeof(a))
#define pb push_back
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define BPC(x) __builtin_popcountll(x)
#define gcd(a,b) __gcd(a,b)
ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}
ll power(ll x,ll n)
{
ll result = 1;
while (n)
{
if (n & 1)
result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
// Solution Function
void solution(ll compte)
{
// cout<<compte<<"\n";
ll a,b,c;
cin>>a>>b>>c;
cout<<min((a+b),min((b+c),(c+a)));
}
// Driver Function
int main()
{
ll compte = 1;
//test()
//{
solution(compte);
compte++;
//}
return 0;
}
| #include<algorithm>
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
int n;
long long ans,a,b,x[100009];
int main(){
scanf("%d%lld%lld",&n,&a,&b);
for(int i=1;i<=n;i++)scanf("%lld",&x[i]);
for(int i=2;i<=n;i++)ans+=min(a*(x[i]-x[i-1]),b);
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <math.h>
#include <algorithm>
#include <deque>
#include <climits>
using namespace std;
#define rep(i,l,r) for(int i=l;i<r;i++)
#define repb(i,r,l) for(int i=r;i>l;i--)
#define ll long long
#define ull unsigned long long
#define ve vector
#define umap unordered_map
#define iter iterator
int main() {
ll x; cin>>x;
ll n = x/11, r = x%11;
if(r>6) cout<<n*2 + 2;
else if(r>0) cout<<n*2 + 1;
else cout<<n*2;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using P = pair<int, int>;
using ll = long long;
void solve()
{
string s;
cin >> s;
rep(bit, 1 << 3)
{
int tmp = s[0] - '0';
string ans;
ans += s[0];
rep(i, 3)
{
if (bit & (1 << i))
{
tmp += s[i + 1] - '0';
ans += "+";
ans += s[i + 1];
}
else
{
tmp -= s[i + 1] - '0';
ans += "-";
ans += s[i + 1];
}
}
if (tmp == 7)
{
printf("%s=7\n", ans.c_str());
return;
}
}
}
int main()
{
solve();
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
bool Bsearch(int key, int A[], int len) {
int l = 0, r = len - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (A[mid] > key)
r = mid - 1;
else if (A[mid] < key)
l = mid + 1;
else
return true;
}
return false;
}
int main() {
int n, *S;
int q, *T;
int ans = 0;
cin >> n;
S = new int[n];
for (int i = 0; i < n; i++)
cin >> S[i];
cin >> q;
T = new int[q];
for (int i = 0; i < q; i++)
cin >> T[i];
sort(S, S + n);
for (int i = 0; i < q; i++)
for (int j = 0; j < n; j++)
if (Bsearch(T[i], S, n) == true) {
ans++;
break;
}
cout << ans << endl;
delete[] S;
delete[] T;
return 0;
} | #include<iostream>
using namespace std;
int main(){
int n,a[10000],m,b,ans=0;
cin>>n;
for(int i=0;i<n;i++)cin>>a[i];
cin>>m;
while(m--){
cin>>b;
for(int i=0;i<n;i++)
if(a[i]==b){ans++;break;}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#define ll long long
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ll sum = 0;
for (int i = 0; i < n; i++) {
if (i != 0) {
if (a[i] < a[i - 1]) {
sum += a[i - 1] - a[i];
a[i] += a[i - 1] - a[i];
}
}
}
cout << sum;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int a[1010],p[1010];
int main(){
int N,M,l,max=0,r;
cin>>N>>M;
for(int i=0;i<N;i++) cin>>a[i];
for(int i=0;i<M;i++){
cin>>l;
for(int j=0;j<N;j++){
if(a[j]<=l){
p[j]++;
break;
}
}
}
for(int i=0;i<N;i++){
if(max<p[i]){
max=p[i];
r=i+1;
}
}
cout<<r<<endl;
return 0;
}
| 0 |
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <functional>
#include <algorithm>
#include <string>
#include <vector>
#include <algorithm>
#include <time.h>
#include <stdlib.h>
#include <math.h>
using namespace std;
int main (void)
{
long m,min,max,p[10000],g[10000],kkk,rrr;
for (long o = 0; o < 10000; o++)
{
cin >> m >> min >> max;
if (m == 0 && min == 0)
{
if (max == 0)
{
break;
}
}
kkk = 0;
for (long i = 1; i < m + 1; i++)
{
cin >> p[i];
}
for (long j = min; j < max + 1; j++)
{
g[j] = p[j] - p[j + 1];
if (kkk <= g[j])
{
kkk = 0;
kkk = g[j];
rrr = 0;
rrr = j;
}
}
cout << rrr << endl;
}
} | #if 1
#include <bits/stdc++.h>
#else
#include "../../bits/stdc++.h"
#endif
#define FOR(i,a,b) for(int i = (a);i < (b);i++)
#define RFOR(i,a,b) for(int i = (b)-1;i >= (a);i--)
#define REP(i,n) FOR(i,0,(n))
#define RREP(i,n) RFOR(i,0,(n))
using namespace std;
typedef pair<int, int> P;
#define pb push_back
#define mp make_pair
#define ft first
#define sd second
int m, nin, nax;
int p[202];
bool input(){
cin>>m>>nin>>nax;
REP(i, m)cin>>p[i];
return m;
}
void solve(){
int s=0, b=0;
FOR(i, nin-1, nax) {
if(p[i]-p[i+1]>=s){
b=i+1;
s=p[i]-p[i+1];
}
}
cout<<b<<endl;
}
int main(){
cin.tie(0);
while (input()){
solve();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
#define SZ(x) ((int)(x).size())
#define PB push_back
template <typename T>
void Puts(T x) {
cout << x << endl;
}
struct Node {
vector<int> parents;
vector<int> children;
int value;
};
int main() {
int n, m;
cin >> n >> m;
auto nodes = vector<Node>(n, Node{
vector<int>(0),
vector<int>(0),
-1});
rep(i, n - 1 + m) {
int a, b;
cin >> a >> b;
a--;
b--;
nodes[a].children.PB(b);
nodes[b].parents.PB(a);
}
auto current = 0;
function<void(int)> dfs = [&](auto index) {
auto &node = nodes[index];
if (node.value != -1) return;
for (auto &childIndex : node.children) {
auto &child = nodes[childIndex];
if (child.value == -1) {
dfs(childIndex);
}
}
node.value = current;
current++;
};
rep(i, n) {
dfs(i);
};
rep(i, n) {
auto &node = nodes[i];
auto &parents = node.parents;
if (SZ(parents) == 0) {
puts("0");
continue;
}
auto minValue = INT_MAX;
auto ans = 0;
for (auto &parentIndex : parents) {
auto &parent = nodes[parentIndex];
if (parent.value < minValue) {
ans = parentIndex + 1;
minValue = parent.value;
}
}
Puts(ans);
}
}
| #include<bits/stdc++.h>
using namespace std;
#define FOR(a, b, c) for(int a = b; a <= c; ++a)
#define fi first
#define se second
#define pb push_back
//#define int long long
typedef pair<int, int> ii;
typedef pair<int, ii> iii;
const int N = 1e5 + 10;
const int oo = 1e18;
int n, m, root, cnt;
int deg[N], ans[N], dp[N], tpid[N], idtp[N];
bool check[N], visit[N];
vector<ii> child[N];
ii edge[N];
stack<int> st;
void dfs(int u) {
visit[u] = 1;
for(auto it: child[u]) if(!visit[it.fi]) {
dfs(it.fi);
}
st.push(u);
}
void solve() {
dfs(root);
while(!st.empty()) {
tpid[st.top()] = ++cnt;
idtp[cnt] = st.top();
st.pop();
}
FOR(i, 1, n) dp[i] = -1;
dp[1] = 0;
FOR(i, 1, n) {
int u = idtp[i];
for(auto it: child[u]) if(dp[tpid[it.fi]] < dp[i] + 1)
dp[tpid[it.fi]] = dp[i] + 1;
}
// FOR(i, 1, n) cout << dp[tpid[i]] << ' '; cout << '\n';
FOR(i, 1, n) {
for(auto it: child[i]) if(dp[tpid[it.fi]] - dp[tpid[i]] > 1)
check[it.se] = 1;
}
FOR(i, 1, n - 1 + m) if(!check[i])
ans[edge[i].se] = edge[i].fi;
FOR(i, 1, n) cout << ans[i] << '\n';
}
signed main() {
// freopen("test.inp", "r", stdin);
// freopen("test.out", "w", stdout);
// ios_base::sync_with_stdio(false); cout.tie(0);
scanf("%d%d", &n, &m);
FOR(i, 1, n - 1 + m) {
int u, v; scanf("%d%d", &u, &v);
edge[i] = {u, v};
child[u].pb({v, i});
deg[v] ++;
}
FOR(i, 1, n) if(deg[i] == 0) root = i;
return solve(), 0;
}
| 1 |
#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(){
ll N, K;
cin >> N >> K;
vl x(N);
rep(i, N) cin >> x[i];
ll ans = (ll)pow(10, 18);
ll dist;
rep(i, N - K + 1){
if(x[i + K - 1] * x[i] < 0)
dist = x[i + K - 1] - x[i] + min(abs(x[i + K - 1]), abs(x[i]));
else
dist = max(abs(x[i + K - 1]), abs(x[i]));
ans = min(ans, dist);
}
cout << ans << "\n";
return 0;
}
| #define MOD_TYPE 1
#pragma region Macros
#include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
//using multiInt = boost::multiprecision::cpp_int;
/*
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
*/
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, greater<Q_type>>;
constexpr ll MOD = (MOD_TYPE == 1 ? (ll)(1e9 + 7) : 998244353);
constexpr int INF = (int)1e9;
constexpr ll LINF = (ll)4e18;
constexpr ld PI = acos(-1.0);
constexpr ld EPS = 1e-11;
constexpr int Dx[] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
constexpr int Dy[] = {1, -1, 0, 0, -1, -1, 1, 1, 0};
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << "\n"
#define Yes(n) cout << ((n) ? "Yes" : "No") << "\n"
#define possible(n) cout << ((n) ? "possible" : "impossible") << "\n"
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << "\n"
#define Yay(n) cout << ((n) ? "Yay!" : ":(") << "\n"
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << "\n";
inline void init_main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(30) << setiosflags(ios::fixed);
}
template <typename T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <typename T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
inline ll CEIL(ll a, ll b)
{
return (a + b - 1) / b;
}
#pragma endregion
int main()
{
init_main();
int h, w;
cin >> h >> w;
int a[80][80], b[80][80];
rep(i, h) rep(j, w) cin >> a[i][j];
rep(i, h) rep(j, w) cin >> b[i][j];
bool dp[80][80][160 * 81] = {};
const int add = 80 * 80;
dp[0][0][a[0][0] - b[0][0] + add] = true;
dp[0][0][b[0][0] - a[0][0] + add] = true;
rep(i, h) rep(j, w)
{
rep(k, 160 * 80)
{
if (!dp[i][j][k])
continue;
if (i + 1 != h)
{
int kk = k + a[i + 1][j] - b[i + 1][j];
if (0 <= kk && kk < 160 * 80)
dp[i + 1][j][kk] = true;
kk = k + b[i + 1][j] - a[i + 1][j];
if (0 <= kk && kk < 160 * 80)
dp[i + 1][j][kk] = true;
}
if (j + 1 != w)
{
int kk = k + a[i][j + 1] - b[i][j + 1];
if (0 <= kk && kk < 160 * 80)
dp[i][j + 1][kk] = true;
kk = k + b[i][j + 1] - a[i][j + 1];
if (0 <= kk && kk < 160 * 80)
dp[i][j + 1][kk] = true;
}
}
}
int Min = INF;
rep(k, 160 * 80)
{
if (!dp[h - 1][w - 1][k])
continue;
int val = abs(k - add);
chmin(Min, val);
}
cout << Min << endl;
return 0;
}
| 0 |
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (int)n; ++i)
constexpr ll INFL = 0x3f3f3f3f3f3f3f3fLL;
int main() {
int n;
cin >> n;
vector<ll> a(n), s(n + 1);
rep(i, 0, n) cin >> a[i];
rep(i, 0, n) s[i + 1] = s[i] + abs(a[i]);
ll minus = INFL, minus_cnt = 0;
rep(i, 0, n) {
if (a[i] == 0) {
minus = INFL;
minus_cnt = 0;
} else {
minus = min(minus, abs(a[i]));
if (a[i] < 0) ++minus_cnt;
}
}
cout << s[n] - (minus_cnt % 2 == 0 ? 0 : minus * 2) << endl;
} | #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<utility>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<bitset>
#include<string>
#include<functional>
#define rep(i,n,m) for(int i=(n);i<(int)(m);i++)
#define reps(i,n,m) for(int i=(n);i<=(int)(m);i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define fs first
#define sc second
#define lb lower_bound
#define ub upper_bound
#define LB(a,x) lb(all(a), x) - a.begin()
#define UB(a,x) ub(all(a), x) - a.begin()
#define printfdouble(x) printf("%.20f\n",(x))
#define chartoint(c) (int)((c) - '0')
#define chartoll(c) (long long)((c) - '0')
#define MOD 1000000007
#define itn int
#define enld endl
#define ednl endl
#define icn cin
#define cotu cout
#define Endl endl
#define stirng string
using namespace std;
typedef long long ll;
const double pi = 3.141592653589793;
using Graph = vector<vector<int>>;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return 1;} return 0;}
template<class T> bool chmin(T &a, const T &b){if(b<a){a=b; return 1;} return 0;}
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main(){
cin.tie(0);ios::sync_with_stdio(false);
ll n; cin >> n;
ll A[300100];
rep(i,0,n) cin >> A[i];
int cnt[65];
Fill(cnt, 0);
rep(i,0,n){
ll tmp = A[i];
int j = 0;
while(tmp > 0){
cnt[j] += (tmp % 2);
tmp /= 2;
j++;
}
}
ll ans = 0;
rep(i,0,60){
ll tmp = modpow(2,i,MOD);
ans += (tmp * (n-cnt[i]) % MOD) * cnt[i] % MOD;
}
ans %= MOD;
cout << ans << endl;
return 0;
}
| 0 |
#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() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int64_t m = s.size();
vector a(1, 0L);
int64_t t = 0;
for (auto c : s) {
if (c == '0') {
a.push_back(t);
} else {
++t;
}
}
a.push_back(t);
int64_t k;
cin >> k;
k = min(k, a.back());
int64_t n = a.size();
constexpr auto M = 998244353L;
vector dp(vector(k + 1, vector(a.back() + 1, 0L)));
int64_t mk = 0;
dp[0][0] = 1;
for (auto i : irange(0L, n - 1)) {
for (auto j : irange(mk, -1L, -1L)) {
for (auto c : irange(0L, a.back() - a[i + 1] + 1)) {
for (auto b : irange(c + 1, c + a[i + 1] - a[i] + 1)) {
auto w = j + b - c;
if (w > k) {
break;
}
mk = max(mk, w);
dp[w][c] += dp[j][b];
if (dp[w][c] >= M) {
dp[w][c] -= M;
}
}
}
for (auto c : irange(1L, a.back() - a[i + 1] + 1)) {
dp[j][c] += dp[j][c - 1];
if (dp[j][c] >= M) {
dp[j][c] -= M;
}
}
}
}
int64_t ans = 0;
for (auto i : irange(0L, k + 1)) {
ans += dp[i][0];
if (ans >= M) {
ans -= M;
}
}
cout << ans << endl;
}
| #pragma GCC optimize ("O2")
#pragma GCC target ("avx2")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const ll mod = 998244353;
ll dp[310][310];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
int K;
int k = 0;
int A[301] = {};
cin >> S >> K;
rep(i, S.size()) {
if (S[i] == '0') k++;
else {
A[k]++;
}
}
int kosuu = 0;
dp[0][0] = 1;
for (int i = k; i >= 0; i--) {
for (int j = kosuu; j >= 0; j--) {
ll tmp = 0;
for (int k = kosuu; k >= 0; k--) {
dp[j][k] %= mod;
tmp += dp[j][k];
rep1(p, A[i]) dp[j + p][k + p] += dp[j][k];
dp[j][k] = tmp;
}
}
kosuu += A[i];
}
ll kotae = 0;
rep(i, min(K, kosuu) + 1) {
kotae += dp[i][0] % mod;
}
co(kotae % mod);
Would you please return 0;
}
| 1 |
#define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
void abc_160a();
void abc_161a();
void abc_162a();
void abc_163a();
int main()
{
//abc_160a();
//abc_161a();
//abc_162a();
abc_163a();
}
void abc_160a()
{
string S;
cin >> S;
if (S[2] == S[3] && S[4] == S[5]) cout << "Yes\n";
else cout << "No\n";
}
void swap(int& a, int& b)
{
int tmp;
tmp = a;
a = b;
b = tmp;
}
void abc_161a()
{
int x, y, z;
cin >> x >> y >> z;
swap(x, y);
swap(x, z);
cout << x << " " << y << " " << z << "\n";
}
void abc_162a()
{
string s;
cin >> s;
for (char c : s)
{
if (c == '7')
{
cout << "Yes\n";
return;
}
}
cout << "No\n";
}
void abc_163a()
{
int R;
cin >> R;
cout << (double)(2 * R * M_PI);
} | #include <bits/stdc++.h>
using namespace std;
int main () {
double a;
cin >> a;
cout << 2*a*3.14159265359 << endl;
}
| 1 |
#define _USE_MATH_DEFINES
#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
typedef long long ll;
using namespace std;
int main()
{
int days[] = {31,29,31,30,31,30,31,31,30,31,30,31};
string week[] = {"Thursday","Friday","Saturday","Sunday","Monday","Tuesday","Wednesday"};
int a,b;
while(~scanf("%d %d",&a,&b)){
if(a==0 && b==0) break;
int passed=0;
for(int i=0;i<a - 1;i++){
passed += days[i];
}
passed += b;
cout << week[(passed - 1) % 7] << endl;
}
} | #include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <cstdio>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <functional>
#include <numeric>
#include <algorithm>
using namespace std;
typedef pair<int,int> P;
typedef long long LL;
#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i,a,b) for(int i = (a); i < (int)(b); ++i)
#define FOREACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define SIZE(v) ((int)v.size())
#define min_3(a,b,c) min(a,min(b,c))
#define max_3(a,b,c) max(a,max(b,c))
#define debug(x) cerr << #x << " = " << (x) << endl;
#define PI 3.1415926535897
#define INF 1000000000
//#define INF 9
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
int main(){
int h,w;
int i,j;
int minh = 0,minw = 0;;
int taikaku;
long long min = 999999999999999;
while(1){
cin >> h >> w;
if(h == 0 && w == 0)break;
min = 99999999999999999;
taikaku = h * h + w * w;
for(i =1;i <= 150 && i * i < taikaku;i++){
j = i + 1;
while(1){//925
int x = i * i + j * j;
if(x == taikaku){
if(x < min && h < i ){
min = x;
minh = i;
minw = j;
break;
}
}
if(x > taikaku){
if(i != h || j != w){
if(min > x){
min = x;
minh = i;
minw = j;
}
}
break;
}
j++;
}
}
cout << minh << " " << minw << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <iterator>
#include <iomanip>
#include <cmath>
#include <vector>
#include <numeric>
#include <cstdio>
#include <bitset>
#include <map>
#include <string>
#include <valarray>
// #include <cctype>
using namespace std;
typedef pair<int, int> Coordinate;
typedef vector<Coordinate> Coordinates;
void output(const vector<int> &);
bool place(const vector<int> &, int pos);
void back_trace(vector<int> & queen, Coordinates & coordinates, int current, int total);
bool match(const vector<int> & queen, const Coordinates & coordinates);
int main()
{
Coordinates coordinates;
vector<int> queen(8);
int n;
cin >> n;
coordinates.resize(n);
int i = 0;
while (i < n)
{
cin >> coordinates[i].first >> coordinates[i].second;
i++;
}
back_trace(queen, coordinates, 0, 8);
}
void output(const vector<int> & queen)
{
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
if (queen[i] == j)
cout << 'Q';
else
cout << '.';
cout << endl;
}
}
bool place(const vector<int> & queen, int current)
{
for (int i = 0; i < current; i++)
if (queen[current]==queen[i] || abs(current-i)==abs(queen[current]-queen[i]))
return false;
return true;
}
void back_trace(vector<int> & queen, Coordinates & coordinates, int current, int total)
{
if (current >= total)
{
if (match(queen, coordinates))
output(queen);
}
else
{
for (int i = 0; i < total; i++)
{
queen[current] = i;
if (place(queen, current))
back_trace(queen, coordinates, current+1, total);
}
}
}
bool match(const vector<int> & queen, const Coordinates & coordinates)
{
for (int i = 0; i < coordinates.size(); i++)
{
if (queen[coordinates[i].first] != coordinates[i].second)
return false;
}
return true;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(int)(n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template<class T> struct edge { int from, to; T cost;};
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 T powerM(T a,T b){if (b==0) return 1;
T tmp = powerM(a,b/2); if (b%2==0) return tmp*tmp%MOD; else return tmp*tmp%MOD*a%MOD; }
template<class T> inline T power(T a,T b,T m){ if (b==0) return 1;
T tmp = power(a,b/2,m); if (b%2==0) return tmp*tmp%m; else return tmp*tmp%m*a%m; }
template<class T> inline T gcd(T a, T b){if (b==0) return a; return gcd(b, a%b);}
template<class T> inline T lcm(T a, T b){return a / gcd(a,b) * b;}
// ax+by=gcd(a,b)を解く
template<class T> inline T extgcd(T a,T b,T &x,T &y){if (b==0){x=1; y=0; return a;} T d=extgcd(b,a%b,y,x); y -= a/b*x; return d;}
void hey(){ cout <<"hey" <<endl; }
int N;
vector<string> field(8, "........");
bool check(int x,int y){
// 攻撃されるならtrue
bool ng = false;
for (int i=0; i<8; i++) if (field[i][y] == 'Q') ng = true;
for (int j=0; j<8; j++) if (field[x][j] == 'Q') ng = true;
int a = x, b = y;
while (a >= 0 && b >= 0) if (field[a--][b--] == 'Q') ng = true;
a = x, b = y;
while (a < 8 && b < 8) if (field[a++][b++] == 'Q') ng = true;
a = x, b = y;
while (a >= 0 && b < 8) if (field[a--][b++] == 'Q') ng = true;
a = x, b = y;
while (a < 8 && b >= 0) if (field[a++][b--] == 'Q') ng = true;
return ng;
}
void rec(int row){
if (row == 8){
rep(i, 8) cout <<field[i] <<endl;
return;
}
// 各行について考える
bool ok = false; rep(i, 8) ok = ok | (field.at(row).at(i) == 'Q');
if (ok) rec(row+1);
// Queenが置かれていなかった場合、置けるところに置く
rep(j, 8){
if (check(row, j)) continue;
field[row][j] = 'Q';
rec(row+1);
field[row][j] = '.';
}
}
int main() {
cin >>N;
rep(q, N){
int x,y; cin >>x >>y;
field[x][y] = 'Q';
}
rec(0);
}
| 1 |
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
template<class S, class T> inline S max_L(S a,T b){
return a>=b?a:b;
}
inline int my_getchar_unlocked(){
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if(s == e && e == 1048576){
e = fread_unlocked(buf, 1, 1048576, stdin);
s = 0;
}
if(s == e){
return EOF;
}
return buf[s++];
}
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = my_getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = my_getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
struct MY_WRITER{
char buf[1048576];
int s;
int e;
MY_WRITER(){
s = 0;
e = 1048576;
}
~MY_WRITER(){
if(s){
fwrite_unlocked(buf, 1, s, stdout);
}
}
}
;
MY_WRITER MY_WRITER_VAR;
void my_putchar_unlocked(int a){
if(MY_WRITER_VAR.s == MY_WRITER_VAR.e){
fwrite_unlocked(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a){
my_putchar_unlocked(a);
}
inline void wt_L(long long x){
int s=0;
int m=0;
char f[20];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
my_putchar_unlocked('-');
}
while(s--){
my_putchar_unlocked(f[s]+'0');
}
}
template<class S, class T> inline S chmax(S &a, T b){
if(a<b){
a=b;
}
return a;
}
int N;
int A[200000];
int main(){
int i;
long long res = 0;
long long mx = -1;
rd(N);
{
int Lj4PdHRW;
for(Lj4PdHRW=(0);Lj4PdHRW<(N);Lj4PdHRW++){
rd(A[Lj4PdHRW]);
}
}
for(i=(0);i<(N);i++){
res +=max_L(mx - A[i], 0);
chmax(mx, A[i]);
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay varsion 20200911-1
// --- original code ---
// int N, A[2d5];
// {
// ll res = 0, mx = -1;
// rd(N,A(N));
// rep(i,N){
// res += max(mx - A[i], 0);
// mx >?= A[i];
// }
// wt(res);
// }
| #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>;
#define chmax(x,y) x = max(x,y)
#define chmin(x,y) x = min(x,y)
const int INF = 1e9 + 10;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
ll ans = 0;
for (int i = 1; i < n; ++i) {
if (a[i-1] <= a[i]) continue;
ans += a[i-1] - a[i];
a[i] = a[i-1];
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#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)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define all(a) (a).begin(),(a).end()
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pll> vp;
typedef vector<ll> vll;
const int MAX_V = 10000;
int V, E;
vi G[MAX_V];
vi rG[MAX_V];
vi vs;
bool used[MAX_V];
int cmp[MAX_V];
void addEdge(int from, int to) {
G[from].emplace_back(to);
rG[to].emplace_back(from);
}
void dfs(int v) {
used[v] = true;
rep(i, G[v].size()) {
if (!used[G[v][i]]) dfs(G[v][i]);
}
vs.emplace_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
rep(i, rG[v].size()) {
if (!used[rG[v][i]]) rdfs(rG[v][i], k);
}
vs.emplace_back(v);
}
int scc() {
memset(used, 0, sizeof(used));
vs.clear();
rep(v, V) {
if (!used[v]) dfs(v);
}
memset(used, 0, sizeof(used));
int k = 0;
for (int i = vs.size() - 1; i >= 0; i--) {
if (!used[vs[i]]) rdfs(vs[i], k++);
}
return k;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> V >> E;
rep(i, E) {
int s, t;
cin >> s >> t;
addEdge(s, t);
}
scc();
int Q;
cin >> Q;
rep(i, Q) {
int u, v;
cin >> u >> v;
cout << (cmp[u] == cmp[v]) << endl;
}
} | #include <bits/stdc++.h>
#define owo(i,a, b) for(int i=(a);i<(b); ++i)
#define uwu(i,a, b) for(int i=(a)-1; i>=(b); --i)
#define senpai push_back
#define ttgl pair<int, int>
#define ayaya cout<<"ayaya~"<<endl
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
gpu_hash_map<int, int> mp;*/
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
const ll root = 62;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
ll binpow(ll a,ll b){ll res=1;while(b){if(b&1)res=(res*a)%MOD;a=(a*a)%MOD;b>>=1;}return res;}
ll modInv(ll a){return binpow(a, MOD-2);}
const double PI = acos(-1);
const double eps = -1e6;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 1001;
int board[mxN][mxN];
int dist[mxN][mxN];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int h, w;
bool inside(int x, int y) {
return x>=0&&x<h&&y>=0&&y<w;
}
int main() {
//freopen("file.in", "r", stdin);
//freopen("file.out", "w", stdout);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin>>h>>w;
string s;
queue<ttgl> Q;
memset(dist, INF, sizeof(dist));
owo(i, 0, h) {
cin>>s;
owo(j, 0, w) {
board[i][j] = s[j]=='#';
if(s[j]=='#') {
Q.push({i, j});
dist[i][j] = 0;
}
}
}
int ans = 0;
while(!Q.empty()) {
auto p = Q.front();
Q.pop();
ans = dist[p.first][p.second];
owo(d, 0, 4) {
if(inside(p.first+dx[d], p.second+dy[d])) {
if(dist[p.first+dx[d]][p.second+dy[d]]==INF) {
dist[p.first+dx[d]][p.second+dy[d]] = dist[p.first][p.second]+1;
Q.push({p.first+dx[d], p.second+dy[d]});
}
}
}
}
cout<<ans<<"\n";
return 0;
} | 0 |
#define MYDEBUG
//
#include <bits/stdc++.h>
#ifdef MYDEBUG
#define dbp(x) cout<<#x<<": "<<x<<endl
#define dbp2(x,y) cout<<#x<<","<<#y<<": "<<x<<","<<y<<endl
#define dbp3(x,y,z) cout<<#x<<","<<#y<<","<<#z<<": "<<x<<","<<y<<","<<z<<endl
#define dbp4(w,x,y,z) cout<<#w<<","<<#x<<","<<#y<<","<<#z<<": "<<w<<","<<x<<","<<y<<","<<z<<endl
#define ifcin(x) std::ifstream cin(x)
#else
#define dbp(x)
#define dbp2(x,y)
#define dbp3(x,y,z)
#define dbp4(w,x,y,z)
#define ifcin(x)
#endif
#define ll long long
#define all(x) x.begin(), x.end()
#define rep(i, from, to) for(int i=from; i<to; ++i)
#define REP(i, from, to) for(int i=from; i<=to; ++i)
using namespace std;
template<typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
out << "[";
size_t last = v.size() - 1;
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
if (i != last) {
out << ",";
}
}
out << "]";
return out;
}
template<typename T>
ostream& operator<<(ostream& out, const vector<vector<T> >& v) {
for (size_t i = 0; i < v.size(); ++i) {
out << v[i] << endl;
}
return out;
}
template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& p) {
out << "{" << p.first << "," << p.second << "}";
return out;
}
static const int MAX = 200000;
static const int INF = INT_MAX;
int n, a[MAX], l[MAX / 2 + 2], r[MAX / 2 + 2];
ll inversion = 0;
void merge(int arr[], int left, int right) {
int mid = (left + right) / 2;
int n1 = mid - left, n2 = right - mid;
rep(i,0,n1)
{
l[i] = a[left + i];
}
rep(j,0,n2)
{
r[j] = a[mid + j];
}
l[n1] = r[n2] = INF;
int i = 0, j = 0;
rep(k,0,right - left)
{
if (l[i] <= r[j]) {
a[left + k] = l[i++];
} else {
a[left + k] = r[j++];
//Lに残った要素の数
//==r[j]より大きい数の個数
//==r[j]より左にあるのに大きい(反転している)数
//各jで反転数(n1-i)を追加
inversion += n1 - i;
}
}
}
void mergeSort(int arr[], int left, int right) {
int mid = (left + right) / 2;
if (left + 1 < right) {
mergeSort(arr, left, mid);
mergeSort(arr, mid, right);
merge(arr, left, right);
}
}
void solve() {
scanf("%d", &n);
rep(i,0,n)
{
scanf("%d", &a[i]);
}
mergeSort(a, 0, n);
printf("%lld\n", inversion);
}
void printTestCase() {
int n = 200000;
int ins = 0;
printf("%d\n", n);
rep(i,0,n)
{
if (ins++ > 0) {
printf(" ");
}
printf("%d", n - i);
}
}
int main() {
solve();
// printTestCase();
return 0;
}
| #include <iostream>
#include <algorithm>
#include <cmath>
#include <complex>
#include <numeric>
#include <array>
#include <bitset>
#include <deque>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include <vector>
using namespace std;
template<typename Itr>
auto merge(Itr first1, const Itr last1, Itr first2, const Itr last2, Itr result){
Itr cpyresult=result;
size_t ret=0;
for(Itr cpyfirst1=first1;; ++cpyresult){
if(cpyfirst1==last1){
//
for(; first2!=last2; ++first2,++cpyresult) *cpyresult=*first2;
break;
}
if(first2==last2){
//
for(; cpyfirst1!=last1; ++cpyfirst1,++cpyresult) *cpyresult=*cpyfirst1;
break;
}
if(*cpyfirst1<=*first2){
*cpyresult=*cpyfirst1;
++cpyfirst1;
} else{
ret+=last1-cpyfirst1; //
*cpyresult=*first2;
++first2;
}
}
for(; result!=cpyresult; ++first1,++result) *first1=*result;
return ret;
}
template<typename Itr>
size_t mergeSort(Itr first, Itr last, Itr result){
if(last-first>1){
Itr mid=first+(last-first)/2;
size_t ret=0;
ret+=mergeSort(first, mid, result);
ret+=mergeSort(mid, last, result);
return ret+merge(first, mid, mid, last, result);
} else return 0;
}
int32_t main(){
size_t n; cin>>n;
vector<uint32_t> s(n),t(n); for(auto&& e:s) cin>>e;
const size_t c=mergeSort(begin(s), end(s), begin(t));
cout<<c<<'\n';
}
| 1 |
#include<bits/stdc++.h>
#define LLI long long int
#define MOD 1000000007
#define de(x) if( x && x == MODE)
#define MODE 0
using namespace std;
char K[100007] = {};
int D;
LLI dp[100007][107] = {};
int main() {
int i,j;
scanf("%s", K+1);
scanf("%d", &D);
int N = strlen(K+1);
K[0] = '0';
int pre = 0;
for (i=0; i < N; i++) {
pre += K[i]-'0';
pre %= D;
for (j=0; j < (K[i+1]-'0'); j++) {
dp[i+1][ (pre+j) % D]++;
dp[i+1][ (pre+j) % D] %= MOD;
}
for (j=0; j<D; j++) {
for (int k=0; k <= 9; k++) {
dp[i+1][ ( (j + k) % D + D ) % D] += dp[i][j];
dp[i+1][ ( (j + k) % D + D ) % D] %= MOD;
}
}
}
pre += K[N]-'0';
pre %= D;
dp[N][pre] = ( dp[N][pre] + 1 ) % MOD;
dp[N][0] = ( dp[N][0] - 1 + MOD) % MOD;
de(1) {
for (i=0; i<=N; i++) {
printf("%d >>> ", i);
for (j=0; j<D; j++) {
printf("%lld ", dp[i][j]);
}
printf("\n");
}
}
printf("%lld\n", dp[N][0]);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define deb(x) cout<< #x << " " << x << "\n";
#define MAX 9223372036854775807
#define MIN -9223372036854775807
#define PI 3.141592653589
#define setbits(n) __builtin_popcountll(n)
const ll mod=1e9+7;
const int N=1e5+1;
ll dp[N][101][2],d,n;
string s;
ll go(ll pos, ll k, ll mx){
if(pos==n){
if(k==0) return 1;
else return 0;
}
if(dp[pos][k][mx]!=-1)
return dp[pos][k][mx];
ll ans=0,lim=s[pos]-'0';
if(mx==0) lim=9;
for(int i=0;i<lim;i++)
ans=(ans+go(pos+1,(k+i)%d,0))%mod;
if(mx==1) ans=(ans+go(pos+1,(k+lim)%d,1))%mod;
else ans=(ans+go(pos+1,(k+lim)%d,0))%mod;
return dp[pos][k][mx]=ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll T=clock();
cin>>s;
cin>>d;
n=s.size();
memset(dp,-1,sizeof(dp));
cout<<(go(0,0,1)-1+mod)%mod;
cerr<<"\n\nTIME: "<<(double)(clock()-T)/CLOCKS_PER_SEC<<" sec\n";
T = clock();
return 0;
} | 1 |
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) range(i,0,b)
#define debug(x) cout << "debug" << x << endl;
using namespace std;
int main(){
int n;
while(cin >> n){
range(i,1,n+1){
int x = i;
if(x % 3 == 0) cout << " " << x;
else{
while(x){
if(x % 10 == 3){
cout << " " << i;
break;
}
x /= 10;
}
}
}
cout << endl;
}
} | // AOJ ITP 1_5_D
#include<cstdio>
void call( int n )
{
int i = 1;
do
{
int x = i;
if( x % 3 == 0 )
printf( " %d", i );
else
{
do
{
if( x % 10 == 3 )
{
printf( " %d", i );
break;
}
x /= 10;
} while( x );
}
}while( ++i <= n );
puts("");
return;
}
int main()
{
int n;
scanf( "%d", &n );
call( n );
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long num, max, a, b=0;
cin >> num >> max;
vector<long long> list2;
for (long long i=0; i<num; i++) {cin >> a; list2.push_back(a);}
sort(list2.begin(),list2.end());
reverse(list2.begin(),list2.end());
for (long long i=0; i<max; i++) {b+=list2[i];}
cout << b;} | #include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define mod 1000000007
ll ceil1(ll n,ll m){if(n%m==0){return n/m;}return n/m +1;}
/*
ll factor(ll n){
vll ans;
if(n==2)ans.pb(2);
else
{for(ll i=2;i*i<=n;i++){if(n%i==0 && n%i!=i){ans.pb(i);if(n/i!=i)ans.pb(n/i);}}ans.pb(n);}
return ans.sz+1;
}
ll fact(ll n){ll res = 1;for (ll i = 2; i <= n; i++)res = res * i;
return res; }
ll nCr(ll n, ll r){ return fact(n) / (fact(r) * fact(n - r)); }
void dfs(vllv &v,ll k,vll &par,vll &dis,ll p)
{
par[k]=p;
dis[k]=dis[p]+1;
for(ll i=0;i<v[k].sz;i++){
if(v[k][i]!=p){
dfs(v,v[k][i],par,dis,k);
}
}
}
bool sortbysec(const pair<string,int> &a,const pair<string,int> &b){return (a.second<b.second);}
ll pow2(ll n,ll k){ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;n=n*n;k/=2;
}return ans;}
bool prime(int n){
int i,j;
for(i=2;i<=sqrt(n);i++){
if(n%i==0){
return false;
}
}
return true;
}
*/
void solve()
{
ll n,k;
cin>>n>>k;
ll a[n];
for(ll i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
ll ans=0;
for(ll i=n-1;i>=0;i--)
{
ans+=a[i];
k--;
if(k==0)
{
cout<<ans;
return;
}
}
}
int main()
{
fast;
ll q;
q=1;
// cin>>q;
while(q--)
{
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Kruskal {
Kruskal() = default;
explicit Kruskal(int n) { init(n); }
struct UnionFind {
vector<int> p, r;
UnionFind() = default;
UnionFind(int size) { init(size); }
void init(int size) {
p.resize(size);
r.resize(size);
for (int i = 0; i < size; ++i) {
p[i] = i;
r[i] = 1;
}
}
int root(int x) {
if (p[x] == x) return x;
else return p[x] = root(p[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return;
if (r[x] > r[y]) swap(x, y);
r[x] += r[y];
p[y] = x;
}
bool same(int x, int y) {
return root(x) == root(y);
}
};
struct edges {
edges() = default;
edges(int u, int v, long long cost) : u(u), v(v), cost(cost) {}
bool operator<(const edges &e) const {
return cost < e.cost;
}
int u, v;
long long cost;
};
struct edge {
edge() {}
edge(int to, long long cost) : to(to), cost(cost) {}
int to;
long long cost;
};
vector<edges> E;
vector<vector<edge>> G;
void init(int n) {
G.resize(n + 1);
}
void add(int u, int v, long long cost) {
E.emplace_back(edges(u, v, cost));
}
void make_graph(edges e) {
G[e.u].push_back(edge(e.v, e.cost));
G[e.v].push_back(edge(e.u, e.cost));
}
long long kruskal(int n) {
long long res = 0;
UnionFind uf(n + 1);
sort(E.begin(), E.end());
for (auto &e : E) {
if (!uf.same(e.u, e.v)) {
res += e.cost;
uf.unite(e.u, e.v);
make_graph(e);
}
}
return res;
}
long long kruskal() {
return kruskal(G.size());
}
};
int main() {
int n, m;
cin >> n >> m;
auto g = Kruskal(n);
for (int i = 0; i < m; ++i) {
int a, b, c;
cin >> a >> b >> c;
g.add(a, b, c);
}
cout << g.kruskal() << endl;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include<string>
using namespace std;
struct Edge{
int P1;
int P2;
int Wei;
};
int main(void){
vector<Edge> EdgeCol;
int V, E;
cin >> V >> E;
if (V == 1){cout << 0<<endl;return 0;}
vector<int>Select(V,0);
for (int i = 0; i < E; ++i){
int s, t, w;
cin >> s >> t >> w;
EdgeCol.push_back(Edge{ s, t, w });
}
sort(EdgeCol.begin(), EdgeCol.end(), [](Edge E1, Edge E2){return E1.Wei > E2.Wei; });
int WeiSum = 0;
int a=1;
while (1){
int aP1 = Select[EdgeCol.back().P1];
int aP2 = Select[EdgeCol.back().P2];
if (aP1 && aP2){
if (aP1 != aP2){
replace(Select.begin(), Select.end(), aP2, aP1);
WeiSum += EdgeCol.back().Wei;
}
}
else if (!aP1 && !aP2){
Select[EdgeCol.back().P1] = a;
Select[EdgeCol.back().P2] = a;
a++;
WeiSum += EdgeCol.back().Wei;
}
else{
Select[EdgeCol.back().P1] = max(aP1, aP2);
Select[EdgeCol.back().P2] = max(aP1, aP2);
WeiSum += EdgeCol.back().Wei;
}
EdgeCol.pop_back();
if (all_of(Select.cbegin(), Select.cend(), [=](int s){return s == *Select.cbegin();})){
cout << WeiSum << endl;
return 0;
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n);i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int,int> P;
constexpr int INF = 2e9;
int main() {
int n, q;
string s;
cin >> n >> s >> q;
while (q--) {
int k;
cin >> k;
ll a = 0, b = 0, c = 0;
ll res = 0;
for (int i = 0; i < n; i++) {
if (i >= k) {
if (s[i - k] == 'D') a--, c -= b;
if (s[i - k] == 'M') b--;
}
if (s[i] == 'D') a++;
if (s[i] == 'M') b++, c += a;
if (s[i] == 'C') res += c;
}
cout << res << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep2(i, m, n) for(int i=int(m); i<int(n); ++i)
#define rep(i, n) rep2(i, 0, n)
using ll = long long;
using V = vector<int>;
using Vll = vector<ll>;
using VV = vector<V>;
using VVll = vector<Vll>;
char s[1000000];
ll t[3][1000001];
int main() {
int n, q;
scanf("%d%s%d", &n, s, &q);
V D, C;
rep(i, n) {
rep(j, 3) t[j][i+1] = t[j][i];
switch(s[i]){
case 'D':
++t[0][i+1];
D.push_back(i);
break;
case 'M':
++t[1][i+1];
break;
case 'C':
++t[2][i+1];
C.push_back(i);
break;
}
}
rep(_, q) {
int k;
scanf("%d", &k);
ll ans = 0;
for (auto &c : C) ans += t[1][c] * (t[0][c] - t[0][max(c-k+1, 0)]);
for (auto &a : D) ans -= t[1][a+1] * (t[2][min(a+k, n)] - t[2][a+1]);
printf("%lld\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(long long i=0;i<(long long)(n);i++)
#define rep2(i, s, n) for(long long i=(s);i<(long long)(n);i++)
#define repi(i, n) for(int i=0;i<(int)(n);i++)
#define rep2i(i, s, n) for(int i=(s);i<(int)(n);i++)
#define all(v) v.begin(), v.end()
#define deg2rad(deg) (((deg)/360)*2*M_PI)
#define rad2deg(rad) (((rad)/2/M_PI)*360)
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
const ll INF = (1LL<<60);
const int INFi = (1<<29);
/*素数判定*/
bool is_prime(ll n){
if(n==1) return false;
for(ll i=2;i*i<=n;i++){
if(n%i==0) return false;
}
return true;
}
/*約数列挙*/
vll enum_divisors(ll n){
vll l;
for(ll i=1;i*i<=n;i++){
if(n%i==0){
l.push_back(i);
if(n/i != i) l.push_back(n/i);
}
}
sort(all(l));
return l;
}
/*素因数分解*/
vector<P> prime_factorize(ll n){
vector<P> l;
for(ll i=2;i*i<=n;i++){
if(n%i!=0) continue;
ll e = 0;
while(n%i==0){
e++;
n /= i;
}
l.push_back({i, e});
}
if(n!=1) l.push_back({n, 1});
return l;
}
/*最小公倍数*/
ll lcm(ll a, ll b){
return a*b/__gcd(a,b);
}
/*最大公約数*/
ll gcd(ll a, ll b){
return __gcd(a,b);
}
/*組み合わせ(Combination)*/
const ll CMAX = 1010000;
const ll CMOD = 1e9+7;
ll fac[CMAX], finv[CMAX], inv[CMAX];
// テーブルを作る前処理
void combinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < CMAX; i++) {
fac[i] = fac[i - 1] * i % CMOD;
inv[i] = CMOD - inv[CMOD%i] * (CMOD / i) % CMOD;
finv[i] = finv[i - 1] * inv[i] % CMOD;
}
}
// 二項係数計算
ll comb(ll n, ll k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % CMOD) % CMOD;
}
int main(){
ll n, q; cin >> n >> q;
string s; cin >> s;
vll l(q), r(q); rep(i, q) cin >> l[i] >> r[i];
vll a(n, 0);
a[0] = 0;
bool b = false;
if(s[0]=='A') b = true;
rep2(i, 1, n){
a[i] = a[i-1];
if(b && s[i]=='C'){
a[i]++;
}
if(s[i]=='A'){
b = true;
}
else{
b = false;
}
}
rep(i, q){
cout << a[r[i]-1]-a[l[i]-1] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
typedef long long ll;
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 long long INF = 1LL << 60;
const int inf = 1001001001;
int main(){
ll n, q;
string s;
cin >> n >> q >> s;
vector<ll> dp(n, 0);
for(ll i = 0; i < n-1; i++){
if(s[i] == 'A' && s[i+1] == 'C'){
dp[i+1] = (dp[i] + 1);
}
else{
dp[i+1] = dp[i];
}
}
while(q){
ll l,r;
cin >> l >> r;
cout << dp[r-1] - dp[l-1] << endl;
q--;
}
} | 1 |
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
int main()
{
int i = 0;
char a[20];
scanf("%s", a);
while (1) {
i++;
if (a[i] == '\0') break;
}
i--;
while (i != -1) {
printf("%c", a[i]);
i--;
}
printf("\n");
return (0);
} | #include <algorithm>
#include <iostream>
#include <string>
int main() {
std::string input;
std::getline(std::cin, input);
std::reverse(input.begin(), input.end());
std::cout << input + '\n';
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repr(i,n) for(int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(),v.end()
typedef long long ll;
int main(){
int N,M;
cin >> N >> M;
vector<int> divisor_list(0);
for (int i = 1; i * i <= M; i++){
if (M % i == 0){
divisor_list.push_back(i);
divisor_list.push_back(M / i);
}
}
sort(all(divisor_list));
int len = divisor_list.size();
int ans = 1;
rep(i,len){
if (M / divisor_list[i] >= N){
ans = divisor_list[i];
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main() {
int a,b;
cin >> a >> b;
if(a%b == 0) cout << 0 << endl;
else cout << 1 << endl;
}
| 0 |
#include <algorithm>
#include <iostream>
#include <limits.h>
#include <string>
#include <vector>
#define el endl
#define fd fixed
using namespace std;
class Point
{
private:
int m_x;
int m_y;
public:
void setX(int x);
void setY(int y);
int getX();
int getY();
Point(int x, int y) {
setX(x);
setY(y);
}
};
void Point::setX(int x) {
m_x = x;
}
void Point::setY(int y) {
m_y = y;
}
int Point::getX() {
return m_x;
}
int Point::getY() {
return m_y;
}
int main() {
int N, x, y, M, l, rx, ry;
string d;
while (1) {
cin >> N;
vector<Point> gems;
if (N == 0) break;
for (int i = 0; i < N; i++) {
cin >> x >> y;
gems.push_back(Point(x, y));
}
cin >> M;
rx = 10;
ry = 10;
while (M--) {
cin >> d >> l;
while (l--) {
if (d == "N") ry++;
if (d == "E") rx++;
if (d == "S") ry--;
if (d == "W") rx--;
for (int i = 0; i < gems.size(); i++) {
if (rx == gems[i].getX() && ry == gems[i].getY()) {
gems.erase(gems.begin()+i);
break;
}
}
}
}
if (gems.empty()) cout << "Yes" << el;
else cout << "No" << el;
}
} | #include <iostream>
#include <string>
using namespace std;
int main(){
int n;
int m;
int c;
int e;
while(cin >>n>>m){
if(n==0&&m==0){break;}
int a[m];
int b[m];
c=0;
while(c<m){
cin >>a[c]>>b[c];
c=c+1;}
int d[n];
d[0]=3;
c=1;
while(c<n){
d[c]=0;
c=c+1;}
c=0;
while(c<m){
if(a[c]==1){d[b[c]-1]=2;}
if(b[c]==1){d[a[c]-1]=2;}
c=c+1;}
c=0;
while(c<m){
if(d[a[c]-1]==2&&d[b[c]-1]==0){d[b[c]-1]=1;}
if(d[b[c]-1]==2&&d[a[c]-1]==0){d[a[c]-1]=1;}
c=c+1;}
e=0;
c=1;
while(c<n){
if(d[c]==1||d[c]==2){e=e+1;}
c=c+1;}
cout <<e<<endl;}} | 0 |
#include<bits/stdc++.h>
using namespace std;
int a[100005],b[100005],c[100005];
vector<int>d[100006];
void dfs(int v,int s) {
a[v]=a[s]+1;
b[v]=1;
c[v]=s;
for(auto x:d[v]) {
if(x==s) continue;
dfs(x,v);
b[v]=max(b[v],b[x]+1);
}
}
int main(){
int n,u,v;
cin>>n>>u>>v;
for(int i=1;i<n;i++) {
int x,y;
cin>>x>>y;
d[x].push_back(y);
d[y].push_back(x);
}
dfs(v,0);
int ans=-1;
int dis=a[u]-a[v];
dis=(dis-1)/2;
// cout<<dis<<endl;
while(dis--){
u=c[u];
}
if(d[u].size()==1)
ans=a[u]-2;
else
ans=b[u]+a[u]-3;
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair <ll,ll> P;
#define REP(i, n) for(ll i = 0LL; i < (ll)(n); i++)
#define REPR(i, n) for(ll i = n-1; i >= 0LL; i--)
#define FOR(i, n, m) for(ll i = n; i < (ll)(m); i++)
#define PRINT(x) cout << x << endl
#define ALL(v) v.begin(), v.end()
#define INF (ll)1e18
#define INFD 1e18
#define PI 3.14159265358979
#define MOD 1000000007
// #define MOD 998244353
#define VL vector<ll>
vector<ll> dx = {-1, 1, 0, 0, -1, -1, 1, 1};
vector<ll> dy = { 0, 0, 1, -1, -1, 1, -1, 1};
ll gcd(ll a, ll b) { return b ? gcd(b,a%b) : a;}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template< typename T >
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
/*
WeightedGraph<ll> g(V);
g[a].emplace_back(b, c);
*/
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename T >
void dijkstra(WeightedGraph< T > &g, vector< T > &dist, vector< T > &prev, vector< T > &num, int s) {
T N = g.size();
dist.resize(N, INF);
prev.resize(N, -1); // 初期化
num.resize(N, 0);
using Pi = pair< T, int >;
priority_queue< Pi, vector< Pi >, greater< Pi > > que;
dist[s] = 0;
que.emplace(dist[s], s);
while(!que.empty()) {
T cost;
int idx;
tie(cost, idx) = que.top();
que.pop();
if(dist[idx] < cost) continue;
for(auto &e : g[idx]) {
auto next_cost = cost + e.cost;
if(dist[e.to] < next_cost) continue;
if (dist[e.to] == next_cost) {
num[e.to] += num[idx];
num[e.to] %= MOD;
continue;
}
dist[e.to] = next_cost;
prev[e.to] = idx; // 頂点 v を通って e.to にたどり着いた
num[e.to] = num[idx];
que.emplace(dist[e.to], e.to);
}
}
return;
}
/* get_path(prev, t)
入力：dijkstra で得た prev, ゴール t
出力： t への最短路のパス
*/
template< typename T >
vector<T> get_path(const vector<T> &prev, T t) {
vector<T> path;
for (T cur = t; cur != -1; cur = prev[cur]) {
path.push_back(cur);
}
reverse(path.begin(), path.end()); // 逆順なのでひっくり返す
return path;
}
int main()
{
ll N, u, v;
cin >> N >> u >> v;
u--; v--;
if (N == 2) {
PRINT(0);
return 0;
}
WeightedGraph<ll> G(N);
REP(i, N-1) {
ll a, b;
cin >> a >> b;
a--; b--;
G[a].emplace_back(b,1);
G[b].emplace_back(a,1);
}
vector<ll> dist1, prev1, num1;
dijkstra(G,dist1,prev1,num1,u);
vector<ll> dist2, prev2, num2;
dijkstra(G,dist2,prev2,num2,v);
// REP(i, N) cout << dist1[i] << " ";
// cout << endl;
// REP(i, N) cout << dist2[i] << " ";
// cout << endl;
ll ma = 0;
REP(i, N) {
if (dist1[i] < dist2[i]) {
ma = max(ma, dist2[i]);
}
}
PRINT(ma-1);
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.