code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <vector>
#include <iostream>
#include <map>
using namespace std;
template<typename T, typename S> vector<T>& operator<<(vector<T>& a, S b) { a.push_back(b); return a; }
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
map<char,int> t;
t['I']=1, t['X']=10, t['V'] = 5;
t['L'] = 50 , t['C'] = 100 , t['M'] = 1000 , t['D'] = 500;
string s;
while(cin >> s){
int ret = 0;
ret += t[s[0]];
rep(i,s.length()-1){
if(t[s[i+1]] > t[s[i]])ret -= 2*t[s[i]];
ret += t[s[i+1]];
}
cout << ret << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
string str;
while(getline(cin, str)) {
int before = 0;
int now;
int ans = 0;
for(int i = 0; i < str.length(); i++) {
switch(str[i]) {
case 'I': now = 1; break;
case 'V': now = 5; break;
case 'X': now = 10; break;
case 'L': now = 50; break;
case 'C': now = 100; break;
case 'D': now = 500; break;
case 'M': now = 1000; break;
}
if(now > before) {
ans = ans - before + (now - before);
} else {
ans += now;
}
before = now;
}
cout << ans << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define pii pair<int,int>
#define fi first
#define se second
#define mp make_pair
#define poly vector<ll>
#define For(i,l,r) for(int i=(int)(l);i<=(int)(r);i++)
#define Rep(i,r,l) for(int i=(int)(r);i>=(int)(l);i--)
#define pb push_back
inline char gc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
#define gc getchar
inline ll read(){
ll x=0;char ch=gc();bool positive=1;
for(;!isdigit(ch);ch=gc()) if(ch=='-') positive=0;
for(;isdigit(ch);ch=gc()) x=x*10+ch-'0';
return positive?x:-x;
}
inline void write(ll x){
if(x<0){
x=-x;putchar('-');
}
if(x>=10) write(x/10);
putchar('0'+x%10);
}
inline void writeln(ll x){write(x);puts("");}
inline void writep(ll x){write(x);putchar(' ');}
inline ull rnd(){
return ((ull)rand()<<30^rand())<<4|rand()%4;
}
const int N=1e5+5;
int a[N],nxt[65][N];
ll id[N];
int main(){
int n=read();
For(i,1,n) a[i]=read(),id[i]=i;
int m=read();ll k=read();
For(i,1,m){
int x=read();
swap(id[x],id[x+1]);
}
For(i,1,n) nxt[0][i]=id[i];
For(i,1,63){
For(j,1,n) nxt[i][j]=nxt[i-1][nxt[i-1][j]];
}
For(i,1,n){
id[i]=i;
Rep(j,63,0) if(k>>j&1) id[i]=nxt[j][id[i]];
id[i]=a[id[i]]-a[id[i]-1];
}
For(i,1,n){
id[i]+=id[i-1];
printf("%lld.0\n",id[i]);
}
} | #include <iostream>
#include <unordered_set>
using namespace std;
typedef long long ll;
int main() {
ll n;
cin >> n;
ll a;
unordered_set<ll> sheet;
for (ll i = 0; i < n; i++) {
cin >> a;
if (sheet.find(a) == sheet.end()) {
//not present, insert
sheet.insert(a);
}
else {
sheet.erase(a);
}
}
cout << sheet.size() << endl;
return 0;
} | 0 |
#include <iostream>
int main(int argc, char** argv)
{
int n;
std::cin >> n;
int min = 1000000;
int max = -1000000;
long long sum = 0;
for (int i = 0; i < n; ++i)
{
int a;
std::cin >> a;
if (min > a)
{
min = a;
}
if (max < a)
{
max = a;
}
sum += a;
}
std::cout << min << " " << max << " " << sum << std::endl;
}
| #include <iostream>
#include <array>
#include <vector>
#include <algorithm>
template<class T>
T input()
{
T val;
std::cin >> val;
return val;
}
int main()
{
long long n, sum = 0;
std::cin >> n;
std::vector<long long> b;
for (int i = 0; i < n; ++i)
b.push_back(input<long long>()), sum += b[i];
std::sort(b.begin(), b.end());
std::cout << b[0] << " " << b[n-1] << " " << sum << std::endl;
return 0;
} | 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>;
int main() {
int n;
cin >> n;
int MAX = -1;
int ans = MAX;
for(int i = 1; i*i <= n; i++) {
ans = max(ans, i*i);
}
cout << ans << endl;
return 0;
} | #include <stdio.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <numeric>
#include <algorithm>
#include <sstream>
#include <string>
#include <map>
#include <set>
using namespace std;
#define rep(i, n) for (int i=0; i<int(n); i++)
int main() {
int64_t N;
cin >> N;
int64_t ans = 1;
for(int i=1; i<N; i++) {
if (i*i<=N) ans = i*i;
else {
cout << ans << endl;
return 0;
}
}
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
const int N=200005;
int a[N],b[N],c[N*3],d[N*3],n;
int main()
{
scanf("%d",&n);
for(int i=0;i<n;i++)
scanf("%d",&a[i]);
for(int i=0;i<n;i++)
scanf("%d",&b[i]);
for(int i=0;i<n;i++)
c[i]=a[i]^a[(i+1)%n],c[i+n*2]=c[i+n]=b[i]^b[(i+1)%n];
int j;d[0]=c[n]=j=-1;
for(int i=0;i<3*n;d[++i]=++j)
while(j>=0&&c[i]!=c[j])
j=d[j];
for(int i=0;i<n;i++)
if(d[n*3-i]==n)
printf("%d %d\n",i,a[i]^b[0]);
return 0;
}
| #include <bits/stdc++.h>
//#include <unistd.h>
//#include <iostream>
using namespace std;
#define DEBUG(x) cerr<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cerr<<#v<<":";for(int i=0;i<v.size();i++) cerr<<" "<<v[i]; cerr<<endl;
#define DEBUG_MAT(v) cerr<<#v<<endl;for(int i=0;i<v.size();i++){for(int j=0;j<v[i].size();j++) {cerr<<v[i][j]<<" ";}cerr<<endl;}
typedef long long ll;
//#define int ll
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
template<class S, class T> pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first + t.first, s.second + t.second); }
template<class S, class T> pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first - t.first, s.second - t.second); }
template<class S, class T> ostream& operator<<(ostream& os, pair<S, T> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
#define X first
#define Y second
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(n);i>0;i--)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(),c.end()
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a = b; return 1; } return 0; }
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = (ll)1e18 + 1;
const long double pi = 3.1415926535897932384626433832795028841971L;
#define Sp(p) cout<<setprecision(25)<< fixed<<p<<endl;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
#define fio() cin.tie(0); ios::sync_with_stdio(false);
const ll MOD = 1000000007;
//const ll MOD = 998244353;
// #define mp make_pair
//#define endl '\n'
vector<int> knuth_morris_pratt(const vi &s){
int n=s.size();
vector<int> kmp(n+1,-1),mp(n+1,-1);
for(int i=0,j=-1;i<n;i++){
while(~j&&s[i]!=s[j]) j=kmp[j];
kmp[i+1]=mp[i+1]=++j;
if(i+1<n&&s[i+1]==s[j]) kmp[i+1]=kmp[j];
}
return mp;
}
// smallest d s.t. s[x] == s[x + d] for all x
vector<int> minimum_period(const vi &s){
auto mp=knuth_morris_pratt(s);
for(int i=1;i<(int)mp.size();i++) mp[i]=i-mp[i];
return mp;
}
// positions for t that match s
vector<int> pattern_match(vi s,vi t){
int n=s.size(),m=t.size();
vector<int> kmp=knuth_morris_pratt(s);
vector<int> res;
int i=0,j=0;
while(i+j<m){
if(s[j]==t[i+j]){
if(++j!=n) continue;
res.emplace_back(i);
}
i+=j-kmp[j];
j=max(kmp[j],0);
}
return res;
}
signed main() {
int n;
cin >> n;
vi a(n), b(n);
rep (i, n) cin >> a[i];
rep (i, n) cin >> b[i];
vi aa(n);
vi bb(2 * n - 1);
rep (i, 2 * n - 1) {
int j = i % n;
bb[i] = b[j] ^ b[(j + 1) % n];
if (i < n) {
aa[i] = a[j] ^ a[(j + 1) % n];
}
}
DEBUG_VEC(aa);
DEBUG_VEC(bb);
vi ans = pattern_match(aa, bb);
DEBUG_VEC(ans);
vector<pii> out;
rrep (i, ans.size()) {
out.emplace_back((n - ans[i]) % n, a[0] ^ b[ans[i]]);
}
sort(all(out));
rep (i, out.size()) {
cout << out[i].first << " " << out[i].second << endl;
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 30;
int main() {
int n, k;
cin >> n >> k;
vector<double> mean(n);
rep(i,n) {
double p; cin >> p;
double m = (p+1) / 2;
mean[i] = m;
}
double ans = 0;
rep(i,k) ans += mean[i];
double r = ans;
//rep(i,n) cout << mean[i] << ' ' ;
for (int i = k; i < n; i++)
{
double now = r - mean[i-k] + mean[i];
r = now;
ans = max(ans, now);
}
cout << fixed << setprecision(10);
cout << ans << endl;
return 0;
} | //Darker and Darker
#include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
using namespace std;
vector<int> dy = {1, 0, -1, 0};
vector<int> dx = {0, 1, 0, -1};
typedef pair<int, int> PII;
int main() {
int h, w;
cin >> h >> w;
vector<string> grah(h);
rep(i, h) cin >> grah.at(i);
queue<PII> q;
vector<vector<int>> dist(h, vector<int>(w, -1));
rep(i,h) rep(j, w){
if(grah.at(i).at(j) == '#'){
q.emplace(i, j);
dist.at(i).at(j) = 0;
}
}
while(!q.empty()){
PII v = q.front();
q.pop();
rep(i, 4){
int ny = v.first + dy.at(i);
int nx = v.second + dx.at(i);
if(ny >= 0 && nx >= 0 && ny < h && nx < w && dist.at(ny).at(nx) == -1 && grah.at(ny).at(nx) != '#'){
dist.at(ny).at(nx) = dist.at(v.first).at(v.second) + 1;
q.emplace(ny, nx);
}
}
}
int res = 0;
rep(i, h) rep(j, w){
res = max(res, dist.at(i).at(j));
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
const double PI = 3.14159265358979323846;
int main() {
vector<int> num(3);
rep(i, 3) cin >> num.at(i);
for(int i = 1; i < 3; i++) {
int tmp = 0;
tmp = num.at(0);
num.at(0) = num.at(i);
num.at(i) = tmp;
}
rep(i, 3) cout << num.at(i) << " ";
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a) (a).begin(),(a).end()
#define endl "\n"
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
typedef long long ll;
void solve() {
int X,Y,Z;
cin >> X >> Y >> Z;
cout << Z << " " << X << " " << Y << endl;
}
int main() {
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (long long i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
const ll MOD = 1000000007;
const ll INF = 10000000000000;
#define all(v) v.begin(), v.end()
int main(){
ll N;
cin >> N;
vector<ll> A(N);
multiset<ll> B;
rep(i,N){
cin >> A.at(i);
if(i==0){
B.insert(A.at(i));
}else{
auto a=B.lower_bound(A.at(i));
if(a==B.begin()){
B.insert(A.at(i));
}else{
a--;
B.erase(a);
B.insert(A.at(i));
}
}
}
cout << B.size() << endl;
} | #include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
int arr[n];
for(int i=0; i<n ; i++)
cin >> arr[i];
for(int j=n-1;j>=0;j--){
if( j!=0)
cout <<arr[j]<<' ';
else
cout <<arr[j];
}
cout << endl;
} | 0 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cassert>
#include <cstdio>
#include <cstdlib>
using namespace std;
using ll = long long;
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
int const nmax = 100000;
int query(int pos){
cout << pos << '\n';
cout << flush;
string s;
cin >> s;
if(s == "Vacant")
exit(0);
else if(s == "Female")
return 1;
else
return 2;
return 0;
}
int v[1 + nmax];
void extract(int from, int to){
if(from + 2 == to)
v[from + 1] = query(from + 1);
else {
int mid = (from + to) / 2;
if((mid - from) % 2 == 1)
mid--;
v[mid] = query(mid);
if(v[from] != v[mid])
extract(from, mid);
else
extract(mid, to);
}
}
int main()
{
int n;
cin >> n;
v[0] = query(0);
v[n - 1] = query(n - 1);
extract(0, n - 1);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int r;
cin >> r;
if(r<1200)
cout << "ABC";
else if(r>=1200 && r<2800)
cout << "ARC";
else
{
cout << "AGC";
}
}
| 0 |
#include <bits/stdc++.h>
#define pb push_back
#define cmin(a,b) (a>b?a=b:a)
#define cmax(a,b) (a<b?a=b:a)
#define lop(i,s,t) for(int i=s;i<(t);++i)
#define rep(i,s,t) for(int i=s;i<=(t);++i)
#define dec(i,s,t) for(int i=s;i>=(t);--i)
#define fore(i,v) for(int i=g[v],d=es[i].d;i;i=es[i].nxt,d=es[i].d)
using namespace std;
#define Pr(f,...) //printf(f,##__VA_ARGS__),fflush(stdout)
typedef long long ll;
const int N=305;
int qk,f[N][N][N],n;
char s[N];
int dp(int l,int r,int k){
if(l>r)return 0;
if(l==r)return 1;
if(f[l][r][k]!=-1)return f[l][r][k];
int &res=f[l][r][k];
res=0;
if(s[l]==s[r])res=max(res,dp(l+1,r-1,k)+2);
res=max(res,dp(l+1,r,k));
res=max(res,dp(l,r-1,k));
if(k)res=max(res,dp(l+1,r-1,k-1)+2);
Pr("f(%d,%d,%d)=%d\n",l,r,k,f[l][r][k]);
return res;
}
int main(int argc,char *argv[]){
scanf("%s",s+1);
n=strlen(s+1);
scanf("%d",&qk);
memset(f,-1,sizeof(f));
cout<<dp(1,n,qk)<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define all(v) v.begin(), v.end()
#define sz(v) int(v.size())
#define pii pair<int, int>
#define mp make_pair
#define f first
#define ll long long
#define ld long double
#define s second
#define vec vector<int>
using namespace std;
const int N = (int) 300 + 10;
const int M = (int) 2018 * 2018;
const int K = (int) 15;
const int INF = (int) 1e9 + 7;
const int mod = (int) 998244353;
const ld EPS = (ld) 1e-9;
const ll LINF = (ll) 1e18;
int n, k;
string s;
int dp[N][N][N];
void upd_max(int &x, int y) {
x = max(x, y);
}
int main() {
#ifdef sony
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
srand(time(0));
cin >> s >> k;
n = sz(s);
for (int i = 0; i < n; i++) {
dp[i][i][0] = 1;
}
for (int len = 2; len <= n; len++) {
for (int i = 0; i + len - 1 < n; i++) {
int j = i + len - 1;
for (int sum = 0; sum <= k; sum++) {
if (s[i] == s[j]) {
upd_max(dp[i][j][sum], dp[i + 1][j - 1][sum] + 2);
} else {
if (sum)
upd_max(dp[i][j][sum], dp[i + 1][j - 1][sum - 1] + 2);
upd_max(dp[i][j][sum], dp[i + 1][j][sum]);
upd_max(dp[i][j][sum], dp[i][j - 1][sum]);
}
}
}
}
int ans = 0;
for (int sum = 0; sum <= k; sum++) {
ans = max(ans, dp[0][n - 1][sum]);
}
cout << ans;
return 0;
} | 1 |
//g++ -std=gnu++14 a.cpp
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
#include <random>
#include <math.h>
#include <stdio.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i = 0; i < (n); i++)
ll MOD = 1e9 + 7;
int INF = 1 << 30;
ll INFL = 1LL << 60;
ll MODP = 998244353;
ll kai(ll x,ll y){
if(y == 0)return 1;
if(y == 1)return x;
if(y&1){
return (x*kai(x,y-1))%MOD;
}else{
ll t = kai(x,y/2);
return (t*t)%MOD;
}
}
ll comb(ll a,ll b,vector<ll> &p){
if(a == 0)return 1;
if(b == 0)return 1;
ll ans = p[a+b];
ans = (ans*kai(p[a],MOD-2))%MOD;
ans = (ans*kai(p[b],MOD-2))%MOD;
return ans;
}
ll mind(int x,vector<int> &v){
int ok = v.size()-1,ng = -1;
while(ok - ng > 1){
int next = (ok+ng)/2;
if(v[next] > x){
ok = next;
}else{
ng = next;
}
}
return ok;
}
ll maxd(int x,vector<int> &v){
int ok = 0,ng = v.size();
while(ng - ok > 1){
int next = (ok+ng)/2;
if(v[next] < x){
ok = next;
}else{
ng = next;
}
}
return ok;
}
int main(){
string S;
cin >> S;
char cur = S.at(0);
ll ans = 0;
ll count = 0;
if(cur == 'R')count++;
for(int i = 1;i <= S.size()-1;i++){
if(cur == 'R' && S.at(i) == 'R'){
count++;
}else if(cur == 'R' && S.at(i) == 'S'){
cur = 'S';
if(ans < count)ans = count;
count = 0;
}else if(S.at(i) == 'R'){
count++;
cur = 'R';
}else{
continue;
}
}
if(count > ans)ans = count;
cout << ans << endl;
return 0;
}
| #include<iostream>
int main()
{
int a = 0;
int Calc=0;
std::cin >> a;
Calc=a+(a*a)+(a*a*a);
std::cout << Calc;
return 0;
} | 0 |
//#define NDEBUG
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <utility>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
struct rep {
struct itr {
usize i;
constexpr itr(const usize i) noexcept : i(i) {}
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
const itr f, l;
constexpr rep(const usize f, const usize l) noexcept
: f(std::min(f, l)), l(l) {}
constexpr auto begin() const noexcept { return f; }
constexpr auto end() const noexcept { return l; }
};
struct revrep {
struct itr {
usize i;
constexpr itr(const usize i) noexcept : i(i) {}
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
const itr f, l;
constexpr revrep(const usize f, const usize l) noexcept
: f(l - 1), l(std::min(f, l) - 1) {}
constexpr auto begin() const noexcept { return f; }
constexpr auto end() const noexcept { return l; }
};
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) noexcept {
if (a < b) {
return b - a;
} else {
return a - b;
}
}
template <class T> void chmin(T &a, const T &b) noexcept {
if (b < a) {
a = b;
}
}
template <class T> void chmax(T &a, const T &b) noexcept {
if (a < b) {
a = b;
}
}
template <class F> class fix_point : private F {
public:
explicit constexpr fix_point(F &&f) : F(std::forward<F>(f)) {}
template <class... Args>
constexpr decltype(auto) operator()(Args &&... args) const {
return F::operator()(*this, std::forward<Args>(args)...);
}
};
template <class F> constexpr decltype(auto) make_fix(F &&f) {
return fix_point<F>(std::forward<F>(f));
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
/*
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
//*/
const usize n = scan<usize>();
std::vector<u32> x(n);
for (auto &e : x) {
std::cin >> e;
}
const u32 l = scan<u32>();
x.push_back(x.back() + l);
auto dp = md_vec(17, n + 1, usize());
for (const usize i : rep(0, n)) {
dp[0][i] = std::distance(
x.cbegin(),
std::prev(std::partition_point(
x.cbegin(), x.cend(), [&](const u32 v) { return v <= x[i] + l; })));
}
dp[0][n] = n;
for (const usize k : rep(1, 17)) {
for (const usize i : rep(0, n + 1)) {
dp[k][i] = dp[k - 1][dp[k - 1][i]];
}
}
const usize q = scan<usize>();
for (const usize i : rep(0, q)) {
usize a = scan<usize>() - 1;
usize b = scan<usize>() - 1;
if (a > b) {
std::swap(a, b);
}
usize ans = 0;
for (const usize k : revrep(0, 17)) {
if (dp[k][a] < b) {
a = dp[k][a];
ans += static_cast<usize>(1) << k;
}
}
std::cout << ans + 1 << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define fi first
#define se second
#define mp make_pair
#define fastIO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int N = 2005;
int f[N][N];
int tot[N][N];
int up[N][N];
int lef[N][N];
int tqr(int il, int jl, int ir, int jr){
if(il > ir || jl > jr) return 0;
return tot[ir][jr] - tot[ir][jl - 1] - tot[il - 1][jr] + tot[il-1][jl-1];
}
int uqr(int il, int jl, int ir, int jr){
if(il > ir || jl > jr) return 0;
return up[ir][jr] - up[ir][jl - 1] - up[il - 1][jr] + up[il-1][jl-1];
}
int lqr(int il, int jl, int ir, int jr){
if(il > ir || jl > jr) return 0;
return lef[ir][jr] - lef[ir][jl - 1] - lef[il - 1][jr] + lef[il-1][jl-1];
}
int main(){
fastIO;
int n, m, q;
cin >> n >> m >> q;
char k;
for(int i = 1; i <= n; i ++ ){
for(int j = 1; j <= m ; j ++ ){
cin >> k;
f[i][j] = k - '0';
tot[i][j] = f[i][j] + tot[i-1][j] + tot[i][j-1] - tot[i-1][j-1];
up[i][j] = (f[i][j] & f[i-1][j]) + up[i-1][j] + up[i][j-1] - up[i-1][j-1];
lef[i][j] = (f[i][j] & f[i][j-1]) + lef[i-1][j] + lef[i][j-1] - lef[i-1][j-1];
}
}
int ci, cj, ri, rj;
for(int i = 0 ; i < q; i ++ ){
cin >> ci >> cj >> ri >> rj;
cout << tqr(ci, cj, ri, rj) - uqr(ci + 1, cj, ri, rj) - lqr(ci, cj + 1, ri, rj) << "\n";
}
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
typedef __int128 LL;
char buf[1<<21],*p1=buf,*p2=buf;
#define getchar() (p1==p2 && (p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
LL read()
{
LL 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;
}
void write(LL x)
{
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
const LL MOD=998244353;
LL QuickPow(LL x,LL p)
{
LL base=x,ans=1;
while(p)
{
if(p&1) ans*=base,ans%=MOD;
p>>=1;
base*=base;
base%=MOD;
}
return ans;
}
LL n,m,fac[1000005],inv[1000005];
LL C(LL n,LL m){return fac[n]*inv[m]%MOD*inv[n-m]%MOD;}
int main(){
n=read(),m=read();
fac[0]=fac[1]=1;
for(LL i=2;i<=1000000;++i) fac[i]=fac[i-1]*i%MOD;
inv[1000000]=QuickPow(fac[1000000],MOD-2);
for(LL i=1000000-1;~i;--i) inv[i]=inv[i+1]*(i+1)%MOD;
LL ans=0;
for(LL i=1;i<=min(n,m);++i)
{
ans+=C(2*i,i)*C(n-i+m-i,n-i)%MOD;
ans%=MOD;
}
ans*=inv[2];
/*
C(2n,n)
*/
ans*=inv[n+m];
ans%=MOD;
ans*=fac[n];
ans%=MOD;
ans*=fac[m];
ans%=MOD;
ans+=max(n,m);
ans%=MOD;
write(ans);
puts("");
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <set>
#include <string>
#include <functional>
#include <cassert>
#include <cmath>
#define SIZE 200005
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
char str[SIZE];
int main(){
int n;
scanf("%d", &n);
scanf("%s", &str);
char pre_s = str[0];
int left = 1;
int right = 0;
int reverse = 1;
ll ret = 1;
for(int i=1; i<2*n; i++)
{
if(pre_s == str[i]) reverse *= -1;
if(reverse == 1) left++;
else if(reverse == -1)
{
ret = (ret * (left - right)) % MOD;
right++;
}
pre_s = str[i];
}
if(left == right && (str[0] == 'B' || str[2*n-1] == 'B'))
{
for(int i=1;i<=n;i++) ret = (ret * i) % MOD;
}
else ret = 0;
printf("%lld\n", ret);
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define LL long long
#define MAXN 310
#define mod 998244353
using namespace std;
int n, f[2][MAXN * MAXN / 2], sum, a[MAXN], ans;
template <typename T> void chkmin(T &x, T y){x = min(x, y);}
template <typename T> void chkmax(T &x, T y){x = max(x, y);}
template <typename T> void read(T &x){
x = 0; int f = 1; char ch = getchar();
while (!isdigit(ch)) {if (ch == '-') f = -1; ch = getchar();}
while (isdigit(ch)) {x = x * 10 + ch - '0'; ch = getchar();}
x *= f;
}
int mul(const int &x, const int &y){return 1ll * x * y % mod;}
int inc(const int &x, const int &y){return (x + y >= mod) ? (x + y - mod) : (x + y);}
void update(int &x, const int &y){x = (x + y >= mod) ? (x + y - mod) : (x + y);}
int dec(const int &x, const int &y){return (x - y < 0) ? (x - y + mod) : (x - y);}
int qpow(int a, int b){
int ret = 1;
while (b) {
if (b & 1) ret = mul(ret, a);
a = mul(a, a);
b >>= 1;
}
return ret;
}
int main(){
read(n);
for (int i = 1; i <= n; ++i)
read(a[i]), sum += a[i];
int cur = 0, old = 1;
f[cur][0] = 1;
for (int i = 1; i <= n; ++i){
swap(cur, old);
memset(f[cur], 0, sizeof(f[cur]));
for (int j = 0; j <= sum / 2; ++j){
if (!f[old][j]) continue;
int tmp = f[old][j];
if (j + a[i] <= sum / 2) update(f[cur][j + a[i]], mul(tmp, 2));
update(f[cur][j], tmp);
}
/*for (int j = 0; j <= sum / 2; ++j)
printf("%d ", f[cur][j]);
puts("");*/
}
for (int i = 0; i <= sum / 2; ++i)
update(ans, f[cur][i]);
//printf("%d\n\n", ans);
ans = mul(ans, 3);
ans = dec(qpow(3, n), ans);
if (!(sum & 1)){
memset(f, 0, sizeof(f));
int cur = 0, old = 1;
f[cur][0] = 1;
for (int i = 1; i <= n; ++i){
swap(cur, old);
memset(f[cur], 0, sizeof(f[cur]));
for (int j = 0; j <= sum / 2; ++j){
if (!f[old][j]) continue;
int tmp = f[old][j];
if (j + a[i] <= sum / 2) update(f[cur][j + a[i]], tmp);
update(f[cur][j], tmp);
}
}
ans = inc(ans, mul(f[cur][sum / 2], 3));
}
printf("%d\n", ans);
return 0;
} | #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <cmath>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <stack>
#include <deque>
#include <set>
#include <map>
#include <queue>
#include <bitset>
#pragma GCC optimize(2)
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
const double eps=1e-5;
const double pi=acos(-1.0);
const int MOD=1e9+7;
const int maxn=1e5+10;
int a[maxn];
int main ()
{
int n;
scanf("%d",&n);
a[0]=1e9;
int len=0;
for(int i=1;i<=n;i++)
{
int x;
scanf("%d",&x);
if(x<=a[len]){
a[++len]=x;
}
else{
int l=1,r=len,mid=(l+r)>>1;
while(l<=r)
{
mid=(l+r)>>1;
if(a[mid]<x){
r=mid-1;
}
else{
l=mid+1;
}
}
//cout<<mid<<endl;
while(a[mid]>=x)
mid++;
a[mid]=x;
}
}
printf("%d\n",len);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int gi(){
char ch=getchar();int x=0,q=0;
while(ch<'0' || ch>'9') ch=='-'?q=1:0,ch=getchar();
while(ch>='0' && ch<='9') x=x*10+ch-'0',ch=getchar();
return q?(-x):x;
}
int f[35000][17],w[35000],c[17][17];
void dp(int &x,int y){
if (x<y) x=y;
return;
}
int main(){
int n=gi(),m=gi(),z,a,b,p,S=(1<<n)-1,d=0;
for (int i=1; i<=m; ++i){
a=gi(),b=gi(),p=gi();
c[a][b]+=p,c[b][a]+=p;
z=(1<<(a-1))|(1<<(b-1));
for (int s=1; s<(1<<n); ++s)
if ((s&z)==z)
w[s]+=p;
d+=p;
}
memset(f,-100,sizeof(f));
f[1][1]=0;
for (int s=1; s<=S; ++s)
for (int i=1; i<=n; ++i)
if (s&(1<<(i-1))){
for (int j=1; j<=n; ++j)
if (!(s&(1<<(j-1)))&&c[i][j])
dp(f[s|(1<<(j-1))][j],f[s][i]+c[i][j]);
for (int t=S^s; t; t=(t-1)&(S^s))
dp(f[s|t][i],f[s][i]+w[t|1<<(i-1)]);
}
int ans=0;
for (int s=1; s<=S; ++s)
dp(ans,f[s][n]);
cout<<d-ans;
return 0;
}
| // besmellah
#include <bits/stdc++.h>
using namespace std;
typedef long long int64;
typedef pair<int,int> pii;
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
const int maxn = 1e4+10;
const int64 MO = 1000000007;
const int64 IN = 1000000000;
int d;
string s;
int dp[maxn][105];
int main () {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> s >> d;
for (int i = 0; i < maxn; i++)
for (int t = 0; t < 105; t++)
dp[i][t] = 0;
dp[0][0] = 1;
for (int i = 0; i <= 9; i++)
dp[1][i % d]++;
for (int i = 2; i <= sz(s); i++)
for (int k = 0; k < d; k++)
for (int t = 0; t <= 9; t++)
dp[i][(t + k) % d] = (dp[i][(t + k) % d] + dp[i - 1][k]) % MO;
int cur = 0;
int ans = -1;
for (int i = 0; i < sz(s); i++) {
for (int t = 0; t < s[i] - '0'; t++) {
int f = (cur + t) % d;
f = (d - f) % d;
ans = (ans + dp[sz(s) - i - 1][f]) % MO;
}
cur = (cur + s[i] - '0') % d;
}
if (cur == 0)
ans++;
ans = (ans + MO) % MO;
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll INF = 1e12;
const ll MOD = 1000000000 + 7;
#define PB push_back
#define PF push_front
#define fi first
#define se second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vpi vector<pii>
#define vll vector<ll>
#define vpl vector<pll>
#define vvi vector<vector<int>>
#define vvl vector<vector<ll>>
#define mii map<int, int>
#define mci map<char, int>
#define mll map<ll, ll>
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define pr_d(x) cout << fixed << setprecision(15) << x << endl
#define ud(c, x) distance(c.begin(), upper_bound(all(c), x))
#define ld(c, x) distance(c.begin(), lower_bound(all(c), x))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define rep3(i, n) for (int i = (n - 1); i >= 0; --i)
#define rep4(i, a, b) for (int i = (a); i > (b); --i)
#define pb push_back
#define out(x) cout << x << "\n"
bool odd(int i) { return i % 2; }
#define all(v) v.begin(), v.end()
#define size(x) int(x.size())
int gcd(int a, int b) { return __gcd(a, b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
void Yes_No(bool f) {
if (f)
printf("Yes\n");
else
printf("No\n");
}
void YES_NO(bool f) {
if (f)
printf("YES\n");
else
printf("NO\n");
}
template <typename T>
void deb1(T x) {
cout << "debug: " << x << "\n";
}
template <typename T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
//-------------------ここから回答する-----------------------
void solve(void) {
ll x;
cin >> x;
ll p = 0;
p = x / 11;
ll ans = 2 * p;
if (x - p * 11 > 0) {
ans++;
if (x - p * 11 > 6) ans++;
}
out(ans);
}
int main(void) { solve(); }
| #include<iostream>
#include<algorithm>
#include<functional>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<deque>
using namespace std;
#define ll long long
const int mod = 1000000007;
const ll INF = 1000000000000000000;
int A[100010];
int cnt[100010];
int main()
{
int N;
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
ll ans = 1;
for (int i = 0; i < N; i++) {
if (A[i] == 0) {
ans *= 3 - cnt[A[0]];
}
else {
ans *= cnt[A[i] - 1] - cnt[A[i]];
}
cnt[A[i]]++;
ans %= mod;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef tree<ll,null_type,less<ll>,rb_tree_tag, tree_order_statistics_node_update> ordered_set;
#define int ll
#define endl "\n"
#define all( x ) x.begin(), x.end()
#define rev_all( x ) x.rbegin(), x.rend()
#define fast ios::sync_with_stdio(0);cin.tie(0);
typedef unsigned long long ull;
const int mod = 1e9 + 7;
const int inf = 1e11 + 5;
const long double PI = 3.141592653589793;
void solve(){
int a, b, c;
cin >> a >> b >> c;
cout << c << " " << a << " " << b <<endl;
return;
}
signed main(){
fast;
int t;
t = 1;
//cin>>t;
while(t--){
solve();
}
} | #include <bits/stdc++.h>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (int)(n); i++ )
using namespace std;
int findSumOfDigits(int n) {
int sum = 0;
while (n > 0) { // n が 0 になるまで
sum += n % 10;
n /= 10;
}
return sum;
}
int main(){
int x, y, z;
cin >> x >> y >> z;
int ansx, ansy, ansz;
ansx = y;
ansy = x;
x = y;
y = ansy;
ansx = z;
ansz = x;
cout << ansx << " " << ansy << " " << ansz << endl;
} | 1 |
#define _GIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
const double EPS = 1e-10;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int bfs(int sx, int sy, int gx, int gy, vector<string>& vs) {
vector<vector<int>> d(vs.size(), vector<int>(vs[0].size(), -1));
queue<P> que;
que.push(P(sx, sy));
d[sy][sx] = 0;
while (que.size()) {
P p = que.front(); que.pop();
if (p.first == gx && p.second == gy) break;
rep(i, 4) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if (0 <= nx && nx < vs[0].size() &&
0 <= ny && ny < vs.size() &&
vs[ny][nx] != '#' && d[ny][nx] == -1) {
d[ny][nx] = d[p.second][p.first] + 1;
que.push(P(nx, ny));
}
}
}
return d[gy][gx];
}
int main(void) {
int H, W;
cin >> H >> W;
vector<string> vs(H);
rep(i, H) cin >> vs[i];
// 幅優先探索で最短経路を求める
int shortest = bfs(0, 0, W - 1, H - 1, vs);
if (shortest == -1) {
cout << -1 << endl;
return 0;
}
int count = 0; // 初期状態の白マス全て
rep(i, H) rep(j, W) if (vs[i][j] == '.') ++count;
// 全ての白マスから、最短経路を除外する
count -= shortest + 1;
cout << count << endl;
return 0;
} | #include<iostream>
#include<queue>
using namespace std;
int main() {
int H, W; cin >> H >> W;
int N = H*W;
int A[N]; string str;
int white_num = 0;
for (int i = 0; i < H; i++) {
cin >> str;
for (int j = 0; j < W; j++) {
white_num += A[i*W+j] = (str[j] == '.');
}
}
queue<pair<int, int>> Q; Q.push(make_pair(0, 1));
bool visited[N]; for (int i = 0; i < N; i++) visited[i] = false;
visited[0] = true;
int score = -1;
while (!Q.empty()) {
auto front = Q.front(); Q.pop();
int u = front.first, d = front.second;
if (u == H*W-1) { score = white_num-d; break; }
vector<int> e;
if (u >= W) e.push_back(u-W);
if (u % W > 0) e.push_back(u-1);
if (u % W < W-1) e.push_back(u+1);
if (u / W < H-1) e.push_back(u+W);
for (int v : e) {
if (A[v] && !visited[v]) {
visited[v] = true;
Q.push(make_pair(v, d+1));
}
}
}
cout << score << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
const int N=305;
#define fi first
#define se second
typedef pair<int,int>P;
priority_queue<P>que;
int n,m,b[N],vi[N],cnt[N],a[N][N];
bool check(int mid){
while(!que.empty()) que.pop();
for(int i=1;i<=m;i++) b[i]=0;
for(int i=1;i<=n;i++) ++b[a[i][cnt[i]=1]];
for(int i=1;i<=m;i++) vi[i]=0,que.push(P(b[i],i));
while(!que.empty()){
P x=que.top(); que.pop();
if(vi[x.se]) continue;
if(x.fi<=mid) return true;
vi[x.se]=1;
for(int i=1;i<=n;i++){
if(a[i][cnt[i]]!=x.se) continue;
while(vi[a[i][cnt[i]]]&&cnt[i]<=m) ++cnt[i];
if(cnt[i]>m) return false;
que.push(P(++b[a[i][cnt[i]]],a[i][cnt[i]]));
}
}
return false;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&a[i][j]);
int l=1,r=n;
while(l<r){
int mid=(l+r)>>1;
if(check(mid)) r=mid;
else l=++mid;
}
printf("%d\n",l);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define rep(i,n) for (int i = 0; i < n; ++i)
#define reps(i,s,n) for (int i = s; i < n; ++i)
#define rep1(i,n) for (int i = 1; i <= n; ++i)
#define per(i,n) for (int i = n - 1; i >= 0; --i)
#define per1(i,n) for (int i = n; i >= 1; --i)
#define all(c) begin(c),end(c)
template<typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> inline T intceil(T a, T b) { return (a + (b - 1)) / b; }
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef tuple<int,int,int> Tint;
typedef pair<ll,ll> PL;
const long long MOD = 1e9+7;
#define precout() cout << std::fixed << std::setprecision(20);
#define print(a) cout << a << endl;
template<typename T> void printv(vector<T>&v) {
int n = v.size() - 1;
rep(i, n) cout << v[i] << " ";
cout << v.back() << endl;
}
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
const int dy[4] = { 0, 1, 0, -1 };
const int dx[4] = { 1, 0, -1, 0 };
// if(nextH >= 0 && nextH < H && nextW >= 0 && nextW < W)
static const long double pi = acos(-1.0);
typedef complex<ld> cd;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N,M; cin >> N >> M;
vector<vector<int>> A(N, vector<int>(M));
rep(i, N) rep(j, M) {
cin >> A[i][j];
--A[i][j];
}
int ans = 1e9;
unordered_set<int> ngS;
while(ngS.size() != M) {
vector<int> cnt(M, 0);
rep(i, N) {
rep(j, M) {
if(ngS.find(A[i][j]) == ngS.end()) {
++cnt[A[i][j]];
break;
}
}
}
int maxCnt = 0, maxCntSports;
rep(i, M) {
if(cnt[i] > maxCnt) {
maxCntSports = i;
maxCnt = cnt[i];
}
}
chmin(ans, maxCnt);
ngS.insert(maxCntSports);
}
print(ans);
}
| 1 |
#include<cstdio>
bool include3(int x){
if(x % 10 == 3){
return true;
}else{
x /= 10;
if(x){
return include3(x);
}
return false;
}
}
bool judge(int x){
if(!(x % 3)){
return true;
}else{
return include3(x);
}
}
int main(){
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i++){
if(judge(i)){
printf(" %d", i);
}
}
printf("\n");
} | #include <vector>
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int m = 1e9;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
m = min(__builtin_ctz(a), m);
}
cout << m << endl;
} | 0 |
#include <iostream>
using namespace std;
typedef long long int LLI;
int main()
{
LLI n, a, b, save;
cin >> n >> a >> b;
LLI first, second, ans = 0;
cin >> first >> second;
save = ( second - first ) * a;
if( save > b )
ans += b;
else
ans += save;
first = second;
for(int i = 2; i < n; i++)
{
cin >> second;
save = ( second - first ) * a;
if( save > b )
ans += b;
else
ans += save;
first = second;
}
cout << ans;
} | #include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define MOD 1000000007
#define MOD2 998244353
#define pb emplace_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define sz(x) (ll)x.size()
#define F first
#define S second
#define FOR(i,a,b) for(ll i=a;i<=b;++i)
#define ROF(i,a,b) for(ll i=a;i>=b;--i)
#define trace(x) cerr<<#x<<": "<<x<<'\n';
typedef long long ll;
using namespace std;
using namespace __gnu_pbds;
#define T int
#define ordered_set tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>
auto clk=clock();
ll mexp(ll a, ll b, ll m){
ll ans=1;
a%=m;
while(b){
if(b&1) ans=ans*a%m;
b>>=1;
a=a*a%m;
}
return ans;
}
const int N = 100005;
ll X[N];
int main(){
IOS
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
ll n, a, b;
cin >> n >> a >> b;
FOR(i,1,n){
cin >> X[i];
}
ll ans = 0;
FOR(i,2,n){
ans += min((X[i] - X[i-1]) * a, b);
}
cout << ans;
cerr<<endl<<endl<<"Time: "<<fixed<<setprecision(12)<<(long double)(clock()-clk)/CLOCKS_PER_SEC<<" ms"<<endl<<endl;
return 0;
} | 1 |
///Bismillahir Rahmanir Rahim
#include<bits/stdc++.h>
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll,ll>
#define clr(x) memset(x,0,sizeof(x));
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define show(x,y) cout<<x<<" : ";for(auto z:y)cout<<z<<" ";cout<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const ll inf=1e18;
const int mod=1e9+7;
const int M=405;
int h,w;
string s[M];
int vis[M][M];
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
int chk(int x,int y)
{
if(x<0 || x>=h || y<0 || y>=w)return false;
if(vis[x][y])return false;
return true;
}
int cw=0,cb=0;
int dfs(int i,int j)
{
vis[i][j]=1;
if(s[i][j]=='#')cb++;
else cw++;
for(int k=0;k<4;k++)
{
int x=dx[k]+i;
int y=dy[k]+j;
if(!chk(x,y))continue;
if(s[i][j]==s[x][y])continue;
dfs(x,y);
}
}
main()
{
fast
cin>>h>>w;
f(i,0,h-1)
{
cin>>s[i];
}
int ses=0;
f(i,0,h-1)
{
f(j,0,w-1)
{
if(vis[i][j])continue;
else
{
cb=cw=0;
dfs(i,j);
ses+=(cb*cw);
}
}
}
cout<<ses<<endl;
return 0;
}
| #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 Would
#define you
#define please
ll BIT1[200010];
ll BIT2[200010];
void add1(int A, ll B) {
while (A > 0) {
BIT1[A] = min(BIT1[A], B);
A -= A & -A;
}
}
ll query1(int A) {
ll kotae = 1e18;
while (A <= 200000) {
kotae = min(kotae, BIT1[A]);
A += A & -A;
}
return kotae;
}
void add2(int A, ll B) {
while (A <= 200000) {
BIT2[A] = min(BIT2[A], B);
A += A & -A;
}
}
ll query2(int A) {
ll kotae = 1e18;
while (A > 0) {
kotae = min(kotae, BIT2[A]);
A -= A & -A;
}
return kotae;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, D;
cin >> N >> D;
int A[200001];
rep1(i, N) cin >> A[i];
rep1(i, 200000) BIT1[i] = 1e18;
rep1(i, 200000) BIT2[i] = 1e18;
rep1(i, N) {
add1(i, A[i] + i * D);
}
rep1(i, N) {
add2(i, A[i] - i * D);
}
ll setuyaku = 0;
for (int i = 2; i < N; i++) {
ll kari1 = query1(i + 1) - i * D;
ll kari2 = query2(i - 1) + i * D;
if (A[i] > min(kari1, kari2)) {
setuyaku += A[i] - min(kari1, kari2);
}
}
ll motomoto = 0;
rep1(i, N - 1) motomoto += A[i];
rep1(i, N - 1) motomoto += A[i + 1];
motomoto += (N - 1) * D;
co(motomoto - setuyaku);
Would you please return 0;
} | 0 |
/// IN THE NAME OF GUITAR
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define sz(x) (ll) x.size()
#define all(x) (x).begin(),(x).end()
#define F first
#define S second
#define lc id << 1
#define rc lc | 1
ll Pow(ll a, ll b, ll md, ll ans = 1) {
for (; b; b >>= 1, a = a * a % md)
if (b & 1)
ans = ans * a % md;
return ans % md;
}
const ll MAXN = 2e3 + 20;
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
ll L[MAXN], R[MAXN], A[MAXN][MAXN], ps[MAXN][MAXN], n, m, ans;
stack<ll> st;
int main() {
scanf("%lld%lld", &n, &m);
for (ll i = 1; i <= n; i++) {
string s;
cin >> s;
for (ll j = 1; j <= m; j++) {
A[i][j] = (s[j - 1] == '#');
}
}
for (ll i = 1; i < n; i++) {
for (ll j = 1; j < m; j++) {
ll cnt = A[i][j] + A[i + 1][j] + A[i][j + 1] + A[i + 1][j + 1];
if (cnt & 1) ps[i][j] = 0;
else ps[i][j] = ps[i - 1][j] + 1;
}
}
ans = max(n, m);
for (ll i = 1; i < n; i++) {
while (sz(st)) st.pop();
st.push(0);
for (ll j = 1; j < m; j++) {
while (sz(st) && ps[i][j] <= ps[i][st.top()]) st.pop();
if (sz(st))
L[j] = st.top();
st.push(j);
}
while (sz(st)) st.pop();
st.push(m);
for (ll j = m - 1; j >= 1; j--) {
while (sz(st) && ps[i][j] <= ps[i][st.top()]) st.pop();
if (sz(st)) R[j] = st.top();
st.push(j);
}
for (ll j = 1; j < m; j++) {
ans = max(ans, (ps[i][j] + 1) * (R[j] - L[j]));
}
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// type alias
typedef long long LL;
typedef pair<int,int> II;
typedef tuple<int,int,int> III;
typedef vector<int> VI;
typedef vector<string> VS;
typedef unordered_map<int,int> MAPII;
typedef unordered_set<int> SETI;
template<class T> using VV=vector<vector<T>>;
// minmax
template<class T> inline T SMIN(T& a, const T b) { return a=(a>b)?b:a; }
template<class T> inline T SMAX(T& a, const T b) { return a=(a<b)?b:a; }
// repetition
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) for(int i=0;i<=(n);++i)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define FORR(x,arr) for(auto& x:arr)
#define SZ(a) int((a).size())
// collection
#define ALL(c) (c).begin(),(c).end()
// DP
#define MINUS(dp) memset(dp, -1, sizeof(dp))
#define ZERO(dp) memset(dp, 0, sizeof(dp))
// stdout
#define println(args...) fprintf(stdout, ##args),putchar('\n');
// debug cerr
template<class Iter> void __kumaerrc(Iter begin, Iter end) { for(; begin!=end; ++begin) { cerr<<*begin<<','; } cerr<<endl; }
void __kumaerr(istream_iterator<string> it) { (void)it; cerr<<endl; }
template<typename T, typename... Args> void __kumaerr(istream_iterator<string> it, T a, Args... args) { cerr<<*it<<"="<<a<<", ",__kumaerr(++it, args...); }
template<typename S, typename T> std::ostream& operator<<(std::ostream& _os, const std::pair<S,T>& _p) { return _os<<"{"<<_p.first<<','<<_p.second<<"}"; }
#define __KUMATRACE__ true
#ifdef __KUMATRACE__
#define dump(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); __kumaerr(_it, args); }
#define dumpc(ar) { cerr<<#ar<<": "; FORR(x,(ar)) { cerr << x << ','; } cerr << endl; }
#define dumpC(beg,end) { cerr<<"~"<<#end<<": "; __kumaerrc(beg,end); }
#else
#define dump(args...)
#define dumpc(ar)
#define dumpC(beg,end)
#endif
// $ cp-batch FlipAndRectangles | diff FlipAndRectangles.out -
// $ g++ -std=c++14 -Wall -O2 -D_GLIBCXX_DEBUG -fsanitize=address FlipAndRectangles.cpp && ./a.out
/*
11/9/2019
16:34-16:41 give up
11/10/2019
15:40- read editorial
http://kmjp.hatenablog.jp/entry/2017/08/24/0930
https://youtu.be/xRYReB8pc2E?t=2803
*/
const int MAX_N=2000+1;
string G[MAX_N];
int H,W;
int cum[MAX_N][MAX_N];
void solve() {
REP(i,H-1) {
cum[i][W-1]=1;
for(int j=W-2; j>=0; --j) {
int cur=G[i][j]==G[i+1][j],r=G[i][j+1]==G[i+1][j+1];
if(cur==r) cum[i][j]=cum[i][j+1];
cum[i][j]+=1;
}
// dumpC(cum[i],cum[i]+W);
}
int res=max(H,W);
REP(j,W) {
stack<II> S; S.emplace(0,0);
REP(i,H) {
int a=cum[i][j],b=i;
while(SZ(S)&&S.top().first>=a) {
auto p=S.top(); S.pop();
int x=i-p.second+1,y=p.first;
SMAX(res,x*y);
b=p.second;
}
S.emplace(a,b);
}
}
cout<<res<<endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout<<setprecision(12)<<fixed;
cin>>H>>W;
REP(i,H) cin>>G[i];
solve();
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
typedef pair<double, double> pd;
typedef vector<pd> vpd;
#define FOR(i,x,y) for(ll i=(ll)x; i<(ll)y; ++i)
#define REP(i,y) FOR(i, 0, y)
#define RFOR(i,x,y) for(ll i=(ll)x; i>=(ll)y; --i)
#define RREP(i,x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) cerr << "line " << __LINE__ << " : "; debug_print_in(x);
template <typename First>
void debug_print_in(First first){
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest){
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void){
return;
}
template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){
cin >> first;
IN(rest...);
return;
}
template <typename First>
void OUT(First first){
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest){
cout << first << " ";
OUT(rest...);
return;
}
template<class t, class u> t chmax(t&a,u b){if(a<b)a=b; return a;};
template<class t, class u> t chmin(t&a,u b){if(a>b)a=b; return a;};
int popcount(int t){return __builtin_popcount(t);} //GCC
int popcount(ll t){return __builtin_popcountll(t);} //GCC
template <typename T>
void vec_print(vector<T> VEC){
REP(i, VEC.size()){
cerr << VEC[i] << " ";
}
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T> > MAT){
REP(i,MAT.size()){
REP(j,MAT[i].size()){
cerr << MAT[i][j] << " ";
}
cerr << endl;
}
};
constexpr int INF = (1<<30);
constexpr ll INFLL = 1LL<<62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9)+7);
int main(){
cin.tie(0); // cut the cin and cout (default, std::flush is performed after std::cin)
ios::sync_with_stdio(false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N;
IN(N);
vpll RL(N);
REP(i,N){
IN(RL[i].second, RL[i].first);
}
sort(ALL(RL));
vll Lmax(N, RL[0].second);
REP(i,N-1){
Lmax[i+1] = max(Lmax[i], RL[i+1].second);
}
/*
REP(i,N){
debug_print(RL[i].second, RL[i].first);
}
*/
ll ans = max(RL[0].first-Lmax[N-2]+1, (ll)0)+(RL[N-1].first-RL[N-1].second)+1;
ll Lmax_after = RL[N-1].second;
for(ll i=N-2; i>0; --i){
ll Lmax1 = Lmax[i-1];
ll Rmin1 = RL[0].first;
ll Lmax2 = RL[i].second;
ll Rmin2 = RL[i].first;
ll LR1 = max(Rmin1-Lmax1+1, (ll)0);
ll LR2 = max(Rmin2-Lmax2+1, (ll)0);
ll LR1_1 = max(Rmin1-max(Lmax_after, Lmax1)+1, (ll)0);
ll LR2_1 = max(Rmin2-max(Lmax_after, Lmax2)+1, (ll)0);
ll ans_tmp = max(LR1+LR2_1, LR1_1+LR2);
chmax(ans, ans_tmp);
chmax(Lmax_after, Lmax2);
}
OUT(ans);
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define sc second
#define mp make_pair
#define pb push_back
#define all(x) x.begin(),x.end()
#define cmin(a,b) (a>b?a=b:a)
#define cmax(a,b) (a<b?a=b:a)
#define mem(a,k) memset(a,k,sizeof(a))
#define lop(i,s,t) for(int i=s;i<(t);++i)
#define rep(i,s,t) for(int i=s;i<=(t);++i)
#define dec(i,s,t) for(int i=s;i>=(t);--i)
#define fore(i,v) for(int i=g[v],d=es[i].d;i;i=es[i].nxt,d=es[i].d)
using namespace std;
#define Pr(f,...) fprintf(stderr,f,##__VA_ARGS__),fflush(stderr)
typedef long long ll;
template<typename T>
void read(T &x){
x=0;
char c;
for(c=getchar();!isdigit(c);c=getchar());
for(;isdigit(c);c=getchar())x=x*10+c-'0';
}
/*
const int N=,P=;
int mul(int a,int b){ return 1ll*a*b%P; }
int add(int a,int b){ a+=b; return a>=P?a-P:a; }
int sub(int a,int b){ a-=b; return a<0?a+P:a; }
int gcd(int a,int b){ return !b?a:gcd(b,a%b); }
*/
const int N=5e5+50;
int n;
typedef pair<int,int> pii;
pii a[N],c[N];
ll ans;
ll L(int a,int b){ return max(b-a+1,0); }
int main(int argc,char *argv[]){
#ifdef CURIOUSCAT
//freopen("d.in","r",stdin);
#endif
scanf("%d",&n);
rep(i,1,n)scanf("%d%d",&a[i].fi,&a[i].sc);
sort(a+1,a+n+1,[](pii a,pii b){return a.sc==b.sc?a.fi<b.fi:a.sc<b.sc; });
sort(a+2,a+n+1,[](pii a,pii b){return a.fi==b.fi?a.sc<b.sc:a.fi<b.fi; });
c[n]=a[n];
dec(i,n-1,2){
c[i].fi=max(a[i].fi,c[i+1].fi);
c[i].sc=min(a[i].sc,c[i+1].sc);
}
//ans=L(c[2].fi,c[2].sc)+L(a[1].fi,a[1].sc);
ll lmax=0;
rep(i,2,n){
ans=max(ans,L(c[i].fi,c[i].sc)+L(max(a[i-1].fi,a[1].fi),a[1].sc));
//Pr("%d,%d---%d,%d\n",c[i].fi,c[i].sc,a[i-1].fi,a[1].sc);
cmax(lmax,L(a[i].fi,a[i].sc));
}
ans=max(ans,lmax+L(max(a[n].fi,a[1].fi),a[1].sc));
printf("%lld\n",ans);
return 0;
}
| 1 |
#include <stdio.h>
#include <math.h>
#define MAXINPUT 100
int main(void){
int h[MAXINPUT],w[MAXINPUT];
int ansh[MAXINPUT]={},answ[MAXINPUT]={};
int i=0,j=0;
int ans=0;
int num=0;
int k;
while(i<MAXINPUT){
scanf("%d %d",&h[i],&w[i]);
if(h[i]==0 && w[i]==0)break;
i++;
num++;
}
for(i=0;i<num;i++,ans=0){
ans=h[i]*h[i]+w[i]*w[i];
for(;(ansh[i]==0||answ[i]==0);){
for(j=1;k==0;j++){
double temp=ans-(j*j);
double tempa=0;
if(temp<=0){
k=1;
break;
}
temp=sqrt(temp);
temp=modf(temp,&tempa);
if(temp==0 && tempa<=150 && j<tempa){
if(tempa*tempa+j*j==h[i]*h[i]+w[i]*w[i] && j<=h[i]){
continue;
}
ansh[i]=j;
answ[i]=(int)tempa;
printf("%d %d\n",ansh[i],answ[i]);
break;
}
}
ans++;
k=0;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
pair<int, int> nxt[256][256];
int main()
{
int h, w;
vector<pair<int, pair<int, int> > > v;
for (int i = 1; i <= 150; i++){
for (int j = i + 1; j <= 150; j++){
v.push_back(make_pair(i * i + j * j, make_pair(i, j)));
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size() - 1; i++){
pair<int, int> now = v[i].second, next = v[i + 1].second;
nxt[now.first][now.second] = next;
}
while (scanf("%d %d", &h, &w) && w){
printf("%d %d\n", nxt[h][w].first, nxt[h][w].second);
}
return (0);
} | 1 |
#include <iostream>
#include <algorithm>
#include <fstream>
using namespace std;
int N = 0, M = 0;
int points[1001];
int scores[1002001];
bool check(int a, int c){
if(a >= (N + 2) * (N + 1) / 2 - 1){
return true;
}
return (scores[a] <= c && scores[a + 1] > c);
}
int search2(int a, int b, int c){
int pib = a + b - b / 2;
if(check(pib, c)){
return pib;
}else if(scores[pib] < c){
return search2(pib, b / 2, c);
}else{
return search2(a, b / 2, c);
}
}
int main(){
for(;;){
for(int i = 0; i < 1001; i++){
points[i] = 0;
}
for(int i = 0; i < 1002001; i++){
scores[i] = 0;
}
if(cin >> N){
if(N == 0){
break;
}
cin >> M;
for(int i = 1; i <= N; i++){
cin >> points[i];
}
for(int i = 0; i <= N; i++){
for(int j = i; j <= N; j++){
scores[(2 * N - i + 1) * i / 2 + j] = points[i] + points[j];
}
}
int mxsco = 0;
sort(scores, scores + ((N + 2) * (N + 1)) / 2);
for(int i = 0; i < (N + 2) * (N + 1) / 2; i++){
if(scores[i] > M){
break;
}
int nosco = scores[i] + scores[search2(0, (N + 2) * (N + 1) / 2, M - scores[i])];
if(nosco >= mxsco && nosco <= M){
mxsco = nosco;
}
}
cout << mxsco << endl;
}else{
break;
}
}
return 0;
} | #include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#define REP(i,k,n) for(int i=k;i<n;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1<<30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
// 0119 B-0563 18:00 ~ 19:00
int main() {
int n, m;
while(cin >> n >> m) {
if(n == 0 && m == 0) break;
vector<ll> v(n);
rep(i, n) cin >> v[i];
sort(v.begin(), v.end());
vector<ll> p;
rep(i, n) p.push_back(v[i]);
rep(i, n) {
REP(j, i, n) {
p.push_back(v[i] + v[j]);
}
}
sort(p.begin(), p.end());
ll ans = 0;
rep(i, p.size()) {
int id = upper_bound(p.begin(), p.end(), m - p[i]) - p.begin();
if(id == 0) {
if(p[i] <= m) ans = max(ans, p[i]);
}
else ans = max(ans, p[i] + p[id-1]);
}
cout << ans << endl;
}
return 0;
} | 1 |
#include<stdio.h>
#include<math.h>
int main(){
double x1, x2;
double y1, y2;
double L, l;
scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
L = (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1);
l = sqrt(L);
printf("%f", l);
return 0;
} | #include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;
int main()
{
double x, y, x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
x = fabs(x2 - x1);
y = fabs(y2 - y1);
if( x == 0 ) {
cout << fixed << setprecision(5) << y << "\n";
return 0;
} else if( y == 0 ) {
cout << fixed << setprecision(5) << x << "\n";
return 0;
}
int c = 0;
double v = x*x + y*y,
d = max(x, y),
eps = 0.00001;
do
{
d = (d + v / d ) / 2.0L;
++c;
}
while( c < 5 );
cout << fixed << setprecision(5) << d << "\n";
return 0;
} | 1 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<math.h>
#include<queue>
#define all(x) (x).begin(),(x).end()
typedef long long ll;
using namespace std;
int main()
{
int K, T, s, ans; cin >> K >> T;
vector<int> v(T);
s = 0;
for(int i=0; i<T; i++){
cin >> v[i];
s += v[i];
}
ans = 0;
for(int i=0; i<T; i++){
if(v[i] >= (s+1)/2) ans += v[i] - (s - v[i]) - 1;
}
cout << ans;
} | #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yn(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YN(ans) if(ans)printf("YES\n");else printf("NO\n")
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
//入力系
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
//出力系
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
//デバッグ系
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
int main(){
INT(k,t);
vector<int> cake(t);
in(cake);
sort(rall(cake));
int day=k-cake[0];
int ans;
if(cake[0]<=day+1)ans=0;
else ans=cake[0]-day-1;
out(ans);
} | 1 |
#include <stdio.h>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <list>
#include <iterator>
#pragma warning(disable:4996)
typedef long long ll;
#define MIN(a, b) ((a)>(b)? (b): (a))
#define MAX(a, b) ((a)<(b)? (b): (a))
#define LINF 9223300000000000000
#define INF 2140000000
#define MOD 1000000007
using namespace std;
const long max_comb=300;
vector<ll> fac(max_comb+1); //n! (mod M)
vector<ll> ifac(max_comb+1); //k!^(-1) (mod M)
ll mpow(ll x, ll n){ //x^n(mod M)
ll ans = 1;
while(n != 0){
if(n&1) ans = ans*x % MOD;
x = x*x % MOD;
n = n >> 1;
}
return ans;
}
ll minv(ll x){
return mpow( x, MOD-2 );
}
ll comb(long a, long b){ // C(a,b) = a! * b!^(-1) * (a-b)^(-1)
if(a == 0 && b == 0)return 1;
if(a < b || a < 0)return 0;
ll tmp = ifac[a-b]* ifac[b] % MOD;
return tmp * fac[a] % MOD;
}
ll perm(long a, long b){ // P(a,b) = a! * (a-b)!^(-1)
if(b == 0)return 1;
if(a < b || a < 0)return 0;
ll tmp = ifac[a-b] % MOD;
return tmp * fac[a] % MOD;
}
void pre_comb()
{
fac[0] = 1;
ifac[0] = 1;
for(long i = 0; i<max_comb; i++){
fac[i+1] = fac[i]*(i+1) % MOD; // n!(mod M)
ifac[i+1] = ifac[i]*minv(i+1) % MOD; // k!^(-1) (mod M)
}
return;
}
ll dp[205][100005];
int main(int argc, char* argv[])
{
long n, x;
scanf("%ld%ld", &n, &x);
vector<long> s(n);
long i,j;
for(i=0; i<n; i++) {
scanf("%ld", &s[i]);
}
sort(s.rbegin(), s.rend());
pre_comb();
dp[0][x]=1;
for(i=0; i<n; i++) {
for(j=0; j<=x; j++) {
if(dp[i][j]) {
ll tmp = minv(n-i);
dp[i+1][j] = (dp[i+1][j] + (dp[i][j]* (1+MOD-tmp)))%MOD;
dp[i+1][j%s[i]] = (dp[i+1][j%s[i]] + dp[i][j]* tmp)%MOD;
}
}
}
ll ans=0;
for(i=0; i<s[n-1]; i++) {
ans = (ans + i*dp[n][i])%MOD;
}
ans = (ans * perm(n,n))%MOD;
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
#define DEBUG 0
#if DEBUG
#define DLOG(...) fprintf(stderr, __VA_ARGS__)
#else
#define DLOG(...)
#endif
void debug(auto f) {
#if DEBUG
f();
#endif
}
ll mPrime = int(1e9) + 7;
ll bN, bX;
vector<ll> bS;
vector<ll> facts;
vector<ll> invFacts;
vector<int> tbl;
vector<int> low; // low[y] == #{ i | s[i] <= y }
ll mAdd(ll x, ll y) {
ll z = x + y;
if (z < mPrime) return z;
else return (z - mPrime);
}
ll mSub(ll x, ll y) {
ll z = x - y;
if (z >= 0) return z;
else return (z + mPrime);
}
ll mMul(ll x, ll y) {
return (x * y) % mPrime;
}
ll eGCD(ll a, ll b, ll& s, ll& t) {
if (a == 0) {
s = 0;
t = 1;
return b;
}
ll u;
ll g = eGCD(b % a, a, t, u);
s = u - (b / a) * t;
return g;
}
ll mInv(ll x) {
ll s, t;
eGCD(x, mPrime, s, t);
return s < 0 ? s + mPrime : s;
}
ll tight(ll);
ll loose(ll y, ll len) {
ll result = mMul(tight(y), mMul(facts.at(len), invFacts.at(low.at(y))));
DLOG("loose(%lld, %lld) = %lld\n", y, len, result);
return result;
}
ll tight(ll y) {
if (tbl.at(y) >= 0) return tbl.at(y);
ll len = low.at(y);
if (len == 0) return y;
ll result = 0;
for (ll i = 0; i < len; i++) {
ll z = y % bS.at(i);
result = mAdd(result, loose(z, len-1));
}
tbl.at(y) = result;
DLOG("tight(%lld) = %lld\n", y, result);
return result;
}
int main() {
cin >> bN >> bX;
bS.resize(bN);
for (ll i = 0; i < bN; i++) {
cin >> bS.at(i);
}
facts.resize(bN+1);
invFacts.resize(bN+1);
facts.at(0) = invFacts.at(0) = 1;
for (ll i = 1; i <= bN; i++) {
facts.at(i) = mMul(i, facts.at(i-1));
invFacts.at(i) = mInv(facts.at(i));
}
sort(bS.begin(), bS.end());
low.resize(bX+1);
ll idx = 0;
for (ll i = 0; i < bX+1; i++) {
if (idx < (ll) bS.size() && bS.at(idx) == i) idx++;
low.at(i) = idx;
}
tbl.resize(bX+1, -1);
ll ans = loose(bX, bS.size());
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
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 NIL = -1;
const int INF = (1<<21);
const long long MOD = 1e9+7;
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
int main() {
int N, M; cin >> N >> M;
int maxL = 0;
int minR = N;
for (int i = 0; i < M; ++i) {
int l ,r; cin >> l >> r;
maxL = max(maxL, l);
minR = min(minR, r);
}
int ans = minR - maxL + 1;
if (ans < 0) cout << 0 << endl;
else cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
int n,m;
cin>>n>>m;
vector<int>pf(n+2);
for(int i=0; i<m; i++){
int a,b;
cin>>a>>b;
pf[a]++;
pf[b+1]--;
}
for(int i=1; i<=n; i++){
pf[i]+=pf[i-1];
}
int cnt=0;
for(int i=1; i<=n; i++){
if(pf[i]==m)
cnt++;
}
cout<<cnt;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int> >;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define irep(i, n) for(int i = n-1; i >= (int)0; i--)
#define reprep(i,j,h,w) rep(i,h)rep(j,w)
#define rrep(i,m,n) for(int i = m; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define aall(x,n) (x).begin(),(x).begin()+(n)
#define VEC(type,name,n) std::vector<type> name(n);rep(i,n)std::cin >> name[i];
#define pb push_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define mp make_pair
#define sum accumulate
#define keta fixed<<setprecision
#define vvector(name,typ,m,n,a)vector<vector<typ> > name(m,vector<typ> (n,a))
#define vvvector(name,t,l,m,n,a) vector<vector<vector<t> > > name(l, vector<vector<t> >(m, vector<t>(n,a)));
#define vvvvector(name,t,k,l,m,n,a) vector<vector<vector<vector<t> > > > name(k,vector<vector<vector<t> > >(l, vector<vector<t> >(m, vector<t>(n,a)) ));
typedef long long ll;
const int INF = 2000000000;
const ll INF64 = 1000000000000000ll;
const ll MOD = 1000000007LL;
int main(){
string s;
std::cin >> s;
std::cout << s.substr(0,s.size()-8) << std::endl;
} | /*#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include <algorithm>
#include<functional>
#include<cstdlib>
#include<cmath>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define CI cin >>
#define CO cout <<
#define E << endl;
using namespace std;
typedef pair<int, int> P;
typedef pair<long, long> LP;
typedef pair<int, P> PP;
typedef pair<long, LP> LPP;
int dy[] = { 0, 0, 1, -1, 0 };
int dx[] = { 1, -1, 0, 0, 0 };
int H = 0;
int M = 0;
int S = 0;
void input(void) {
CI H >> M >> S;
return;
}
int main(void) {
int sum = 0;
int remain = 0;
int hour = 0;
int minute = 0;
int second = 0;
while (1) {
input();
if (H == -1) {
return 0;
}
sum = H * 3600 + M * 60 + S;
remain = 2 * 3600 - sum;
second = remain % 60;
remain -= remain % 60;
remain /= 60;
minute = remain % 60;
remain -= remain % 60;
remain /= 60;
hour = remain
}
return 0;
}*/
/*#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include <algorithm>
#include<functional>
#include<cstdlib>
#include<cmath>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define CI cin >>
#define CO cout <<
#define E << endl;
using namespace std;
typedef pair<int, int> P;
typedef pair<long, long> LP;
typedef pair<int, P> PP;
typedef pair<long, LP> LPP;
int dy[] = { 0, 0, 1, -1, 0 };
int dx[] = { 1, -1, 0, 0, 0 };
int H = 0;
int M = 0;
int S = 0;
void input(void) {
CI H >> M >> S;
return;
}
int main(void) {
int sum = 0;
int remain = 0;
int hour = 0;
int minute = 0;
int second = 0;
while (1) {
input();
if (H == -1) {
return 0;
}
sum = H * 3600 + M * 60 + S;
remain = 2 * 3600 - sum;
second = remain % 60;
remain -= remain % 60;
remain /= 60;
minute = remain % 60;
remain -= remain % 60;
remain /= 60;
hour = remain
}
return 0;
}*/
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<string.h>
#include<vector>
#include<math.h>
#include<queue>
#include <algorithm>
#include<functional>
#include<cstdlib>
#include<cmath>
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define CI cin >>
#define CO cout <<
#define E << endl;
using namespace std;
int dy[] = { 0, 0, 1, -1, 0 };
int dx[] = { 1, -1, 0, 0, 0 };
const long long int III = 1000010;
string str;
void input(void) {
CI str;
return;
}
int main(void) {
input();
long long int f_j = 0;
long long int f_o = 0;
long long int f_i = 0;
long long int max_k = 0;for (int i = 0; i < str.size(); i++) {
if (str[i] == 'J') {
if (f_o == 0 && f_i == 0) {
f_j++;
}
if (f_o != 0 || f_i != 0) {
f_j = 1;
f_o = 0;
f_i = 0;
}
}
else {
if (f_j > 0 && f_o != f_j && f_i == 0 && str[i] == 'O') {
f_o++;
}
else {
if (f_o > 0 && f_i != f_o && str[i] == 'I') {
f_i++;
if (f_j >= f_o && f_o == f_i) {
if (f_o > max_k) {
max_k = f_o;
}
f_j = 0;
f_o = 0;
f_i = 0;
}
}
else {
f_j = 0;
f_o = 0;
f_i = 0;
}
}
}
}
CO max_k E
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++i)
#define per(i, a, b) for (int i = (a), i##end = (b); i >= i##end; --i)
namespace IO {
#define gc getchar()
template <typename T>
inline void read(T& x) {
x = 0; bool f = 1; char ch;
for (ch = gc; ch < '0' || '9' < ch; ch = gc) if (ch == '-') f ^= 1;
for (; '0' <= ch && ch <= '9'; ch = gc) x = (x << 3) + (x << 1) + (ch ^ 48);
x = f ? x : -x;
}
#undef gc
}
const int MAXN = 2e5 + 10;
int n, arr[2][MAXN], cnt[2][MAXN], val;
vector<int> pos;
int main() {
IO::read(n);
rep(_, 0, 1) rep(i, 1, n) IO::read(arr[_][i]), cnt[_][arr[_][i]]++;
reverse(arr[1] + 1, arr[1] + n + 1);
rep(i, 1, n) if (arr[0][i] == arr[1][i]) val = arr[0][i], pos.push_back(i);
int l = 1, r = n; bool flg = false;
for (auto cur_pos : pos) {
if (flg == false) {
if (arr[0][l] != val && arr[1][l] != val) {
swap(arr[1][l], arr[1][cur_pos]);
++l;
} else flg = true;
}
if (flg == true) {
if (arr[0][r] != val && arr[1][r] != val) {
swap(arr[1][r], arr[1][cur_pos]);
--r;
} else return puts("No"), 0;
}
}
puts("Yes");
rep(i, 1, n) printf("%d ", arr[1][i]);
return 0;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <random>
using namespace std;
using namespace __gnu_pbds;
typedef
tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, tree_order_statistics_node_update> orderedSet;
#define pb push_back
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define for1(i0, l0, r0) for (int i0 = l0; i0 < r0; ++i0)
#define for2(i0, l0, r0) for (int i0 = l0; i0 <= r0; ++i0)
#define forn(i0, n0) for (int i0 = 0; i0 < n0; ++i0)
#define forn1(i0, n0) for (int i0 = 1; i0 < n0; ++i0)
#define forr(i0, n0) for (int i0 = n0; i0 >= 0; --i0)
#define forr1(i0, r0, l0) for (int i0 = r0; i0 > l0; --i0)
#define forr2(i0, r0, l0) for (int i0 = r0; i0 >= l0; --i0)
#define Sort(a) sort(all(a))
#define Reverse(a) reverse(all(a))
#define relaxMax(a, b) a = max(a, b)
#define relaxMin(a, b) a = min(a, b)
typedef long long ll;
typedef long double ld;
#define ui unsigned int
#define ull unsigned long long
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef pair<string, string> pss;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<ld> vld;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pdd> vpdd;
typedef vector<vi> vvi;
typedef vector<vd> vvd;
typedef vector<vll> vvll;
typedef vector<vb> vvb;
#define vpss vector<pss>
#define vvs vector<vs>
#define vvpii vector<vpii>
#define vvpll vector<vpll>
#define vpt vector<pt>
#define vvvi vector<vvi>
#define vsi vector<set<int>>
#define ss second
#define ff first
#define printvi(arr) for (int x0 : arr) cout << x0 << ' '; cout << '\n';
#define printvll(arr) for (ll x0 : arr) cout << x0 << ' '; cout << '\n';
#define printpair(pair0) cout << pair0.F << ' ' << pair0.S << '\n';
#define printvp(arr) for (auto pair0 : arr) printpair(pair0);
#define initArray(arr, N0, X0) memset(arr, X0, N0 * sizeof(int))
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
//cout.precision(16);
//freopen("amusing.in", "r", stdin);
//freopen("amusing.out", "w", stdout);
}
const int maxn = 2e5 + 1;
const int mod = 1e9 + 7;
vll fact(maxn);
vll invfact(maxn);
ll powmod(ll a, ll b) {
if (b == 0) return 1;
if (b % 2 == 0) {
ll x = powmod(a, b / 2);
return (x * x) % mod;
}
return (a * powmod(a, b - 1)) % mod;
}
void calcFactorials() {
fact[0] = 1;
forn1(i, maxn) fact[i] = (fact[i - 1] * (ll) i) % mod;
forn(i, maxn) invfact[i] = powmod(fact[i], mod - 2);
}
ll cnk(int n, int k) {
return ((fact[n] * invfact[k]) % mod) * invfact[n - k] % mod;
}
int h, w;
ll numberOfWays(int x, int y){
int dx1 = x - 1, dy1 = y - 1;
int dx2 = h - x - 1, dy2 = w - y;
return (cnk(dx1 + dy1, dx1) * cnk(dx2 + dy2, dx2)) % mod;
}
void solve() {
calcFactorials();
int a, b;
cin >> h >> w >> a >> b;
ll ans = 0;
for2(i, b + 1, w){
ans += numberOfWays(h - a, i);
ans %= mod;
}
cout << ans << '\n';
}
bool multitest = false;
int main() {
init();
int t = 1;
if (multitest) cin >> t;
forn(i, t) solve();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n,m;
cin >> n >> m;
int l1 = 1;
int r1 = m+1;
int l2 = m+2;
int r2 = 2*m+1;
for(int i=0;i<m;i++)
{
if(l1 < r1)
{
cout << l1 << ' ' << r1 << '\n';
l1++;
r1--;
}
else if(l2 < r2)
{
cout << l2 << ' ' << r2 << '\n';
l2++;
r2--;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{
int64_t N, M;
vector<pair<int, int>> ans;
cin >> N >> M;
if (N % 2)
{
for (int l = 0, r = N - 1; l < r; l++, r--)
{
ans.emplace_back(l, r);
}
}
else
{
bool flag = true;
for (int l = 0, r = N - 1; l < r; l++, r--)
{
if (flag && r - l <= N / 2)
{
r--;
flag = false;
}
ans.emplace_back(l, r);
}
}
for (int i = 0; i < M; i++)
{
cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << endl;
}
} | 1 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
using namespace std;
typedef pair<double,string> pa;
vector<pa> vec;
bool my (pa i,pa j) { return (i.first==j.first?i.second>j.second:i.first<j.first); }
int main(){
int n;
while(cin >> n && n){
while(n--){
string na;
double p,a,b,c,d,e,f,s,m;
cin>>na>>p>>a>>b>>c>>d>>e>>f>>s>>m;
vec.push_back(pa((f*s*m-p)/(a+b+c+(d+e)*m),na));
}
sort(vec.begin(),vec.end(),my);
for(long long i=vec.size()-1;i>=0;i--){
cout<<vec[i].second<<endl;
}
cout<<"#"<<endl;
vec.clear();
}
} | #include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
bool is_prime[10001];
int prime[10001];
int main() {
memset(is_prime, 1, sizeof(is_prime));
is_prime[0] = is_prime[1] = false;
int p = 0;
for (int i = 2; i <= 10000; i++) {
if (is_prime[i]) {
prime[p++] = i;
for (int j = i * 2; j <= 10000; j += i)is_prime[j] = false;
}
}
int n;
while (scanf("%d", &n), n) {
int a = upper_bound(prime, prime + p, n) - prime - 1;
for (int i = a; i > 0; i--) {
if (prime[i] - prime[i - 1] == 2) {
printf("%d %d\n", prime[i - 1], prime[i]);
break;
}
}
}
} | 0 |
#include<iostream>
#include<vector>
using namespace std;
using ll = long long;
int main(){
int n;
cin>>n;
vector<ll> c(100005);
for(int i=0;i<n;i++){
int d;
cin>>d;
c[d]++;
if(i==0&&d!=0){
cout<<0<<endl;
return 0;
}
}
ll ans=0;
if(c[0]==1) ans=1;
for(int i=1;i<n;i++){
for(int j=0;j<c[i];j++){
ans*=c[i-1];
ans%=998244353;
}
}
cout<<ans<<endl;
} | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <chrono>
#include <random>
#include <time.h>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep3(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pq priority_queue<int>
#define pqg priority_queue<int,vector<int>,greater<int>>
#define pb push_back
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define endl "\n"
#define all(c) begin(c),end(c)
using namespace std;
int in() {int x;scanf("%d",&x);return x;}
ll lin() {ll x;scanf("%lld",&x);return x;}
#define INF 1e9+7
#define LLINF 1e18+7
#define N 500000
ll MOD=1e9+7;
vec mem(20,-1);
main(){
int n=in();
ll x=in();
vector<ll> b,l,r,t;
rep(i,n){
b.pb(in());
l.pb(in());
r.pb(in());
t.pb(l[i]*b[i]+(r[i])*(x-b[i]));
}
vec ind;
rep(i,n)ind.pb(i);
sort(all(ind),[&](int y,int z){
return t[y]>t[z];
});
//cout<<t[0]<<" "<<t[1]<<endl;
ll left=-1,right=n*x;
while(left<right-1){
ll mid=(left+right)/2;
ll mm=mid;
ll tmp=0;
rep(i,n){
tmp-=b[i]*l[i];
}
int now=0;
bool flag=false;
while(mid>=x){
tmp+=t[ind[now]];
if(tmp>=0){
flag=true;break;
}
mid-=x;
now++;
}
if(flag){
right=mm;continue;
}
ll MAX=0;
ll T=1e11;
rep2(j,0,now-1){
int i=ind[j];
if(mid>=b[i]){
T=min(T,(x-mid)*r[i]);
}
else{
T=min(T,(x-b[i])*r[i]+(b[i]-mid)*l[i]);
}
}
rep2(j,now,n-1){
int i=ind[j];
if(mid>=b[i]){
MAX=max(MAX,b[i]*l[i]+(mid-b[i])*r[i]);
}
else{
MAX=max(MAX,l[i]*mid);
}
MAX=max(MAX,t[i]-T);
}
tmp+=MAX;
if(tmp>=0)right=mm;
else left=mm;
}
cout<<right;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#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 ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
string to_string(T s);
template <class S, class T>
string to_string(pair<S, T> p);
string to_string(string s);
string to_string(const char s[]) { return string(s); }
template <class T>
string to_string(T v) {
if (v.empty()) return "{}";
string ret = "{";
auto itr = v.begin(), next = ++v.begin();
for (; next != v.end(); ++itr, ++next) ret += to_string(*itr) + ",";
ret += to_string(*itr) + "}";
return ret;
}
template <class S, class T>
string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
string to_string(string s) { return s; }
void debug() { cerr << endl; }
template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head head, Tail... tail) {
cout << to_string(head) << " ";
print(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
string separator = " ";
template <class T>
inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus) x = -x;
}
inline void read(string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T>
inline void read(vector<T> &v) {
for (auto &x : v) read(x);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &... tail) {
read(head);
read(tail...);
}
template <class T>
inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0) putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x) putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i) putchar_unlocked(s[i]);
}
template <class T>
inline void write(vector<T> v) {
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
void set_separator(string s) { separator = s; }
} io;
int main() {
int N;
io.read(N);
vector<int> A(N);
io.read(A);
sort(ALL(A), greater<int>());
map<int, int> mp;
for (auto x : A) mp[x]++;
int ans = 0;
REP(i, N) {
if (mp[A[i]] < 1) continue;
REP(t, 31) {
int x = 1 << t;
int pad = x - A[i];
if (mp.count(pad) && (mp[pad] > (A[i] == pad))) {
ans++;
mp[pad]--;
mp[A[i]]--;
break;
}
}
}
io.write(ans);
io.write("\n");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
inline void prep ()
{
cin.tie (0);
cin.sync_with_stdio (0);
};
const double pi = acos(-1.);
//printf(%.12lf\n,mid);
// __builtin_popcount(int) count 1's in binary
// get decimal part of number
/*
double intpart;
double thiss = modf((double)(n*m)/(double)k, &intpart);
*/
// round = (int)(num+.5)
long long mod = 1000000007;
long long mymod(long long num){
if (num< 0 && !(num%mod == 0)){
if (mod == 1){
return 0;
}
return mod-abs(num)%mod;
}else{
return num%mod;
}
}
/*string sentence = And I feel fine...;
istringstream iss(sentence);
*/
double eps = .000000001;
int main(){
prep();
int n, m;
cin >> n >> m;
int arr[n][m];
for (int i=0; i<n; i++){
for (int j=0; j<m; j++){
cin >> arr[i][j];
arr[i][j]--;
}
}
int pointers[n] = {0};
int cnts[m] = {0};
int res = 0;
for (int i=0; i<n; i++){
cnts[arr[i][0]]++;
}
for (int i=0; i<m; i++){
res = max(res, cnts[i]);
}
bool erased[m] = {false};
for (int x=0; x<m-1; x++){
int maxx = 0;
int maxind = 0;
for (int i=0; i<m; i++){
if (cnts[i] > maxx){
maxx = cnts[i];
maxind = i;
}
}
erased[maxind] = true;
for (int i=0; i<n; i++){
cnts[arr[i][pointers[i]]]--;
while (erased[arr[i][pointers[i]]]){
pointers[i]++;
}
cnts[arr[i][pointers[i]]]++;
}
maxx = 0;
for (int i=0; i<m; i++){
maxx = max(cnts[i], maxx);
}
res = min(res, maxx);
}
cout << res;
return 0;
} | 0 |
///Bismillahir Rahmanir Rahim
#include "bits/stdc++.h"
#pragma GCC optimize("Ofast")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma warning(disable:4786)
#pragma warning(disable:4996)
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll,ll>
#define node(a,b,c) mp(mp(a,b),c)
#define clr(x) memset(x,0,sizeof(x));
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define show(x,y) cout<<x<<" : ";for(auto z:y)cout<<z<<" ";cout<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const ll inf=1e18;
const int mod=1e9+7;
const int M=100005;
vector<int>adj[M];
int n,m;
int in[M];
int par[M];
void dfs(int u)
{
for(auto v:adj[u])
{
if(in[v]==1)
{
par[v]=u;
}
else
{
in[v]--;
}
}
for(auto v:adj[u])
{
if(par[v]==u)
{
dfs(v);
}
}
}
main()
{
fast
cin>>n>>m;
f(i,1,n-1+m)
{
int u,v;
cin>>u>>v;
adj[u].pb(v);
in[v]++;
}
int root=0;
f(i,1,n)
{
if(in[i]==0)root=i;
}
dfs(root);
f(i,1,n)
{
cout<<par[i]<<"\n";
}
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_r(i, n) for (int i = n - 1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((ll)(x).size())
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define INF bit(60)
#define pb push_back
#define mod 1000000007
using namespace std;
using uif = uint_fast64_t;
using ll = long long int;
using tTree = __gnu_pbds::tree<ll, __gnu_pbds::null_type, less<ll>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;
ll dx[4] = {1, 0, -1, 0};
ll dy[4] = {0, 1, 0, -1};
#define FACSIZE 200002
ll invfac[FACSIZE];
ll fac[FACSIZE];
template <class T>
bool chmax(T &, const T &);
template <class T>
bool chmin(T &, const T &);
ll gcd(ll, ll);
ll powLL(ll x, ll y);
ll mod_pow(ll, ll);
ll mod_add(ll, ll);
ll mod_mul(ll, ll);
ll mod_div(ll, ll);
ll comb(ll, ll);
void make_fact(ll);
void make_invfact(ll);
void fact_init();
int main(void)
{
ll n, m;
cin >> n >> m;
vector<ll> a(n + m - 1);
vector<ll> b(n + m - 1);
rep(i, n + m - 1) cin >> a[i] >> b[i];
vector<ll> dis(n + 1, 0);
vector<vector<ll>> par(n + 1);
vector<vector<ll>> child(n + 1);
vector<ll> cnt(n + 1, 0);
vector<ll> ans(n + 1, -1);
rep(i, n + m - 1)
{
auto p = a[i];
auto c = b[i];
par[c].push_back(p);
child[p].push_back(c);
}
ll root;
rep1(i, n)
{
if (par[i].empty())
root = i;
cnt[i] = par[i].size();
}
//cout << root << endl;
queue<pair<ll, ll>> que;
que.push(make_pair(root, 0));
dis[root] = 0;
ans[root] = 0;
while (!que.empty())
{
auto q = que.front();
auto p = q.first;
auto d = q.second;
que.pop();
for (auto c : child[p])
{
if (dis[c] < d + 1)
{
if (cnt[c] > 1)
{
cnt[c]--;
continue;
}
dis[c] = dis[p] + 1;
ans[c] = p;
que.push(make_pair(c, dis[c]));
}
}
}
/*
for (auto x : ans)
cout << x << " ";
cout << endl;
//*/
rep1(i, n) cout << ans[i] << endl;
return 0;
}
ll mod_pow(ll x, ll r)
{
if (r == 0)
return 1;
else if (r == 1)
return x % mod;
else if (r % 2 == 0)
{
ll t = mod_pow(x, r / 2) % mod;
return mod_mul(t, t);
}
else
{
ll t = mod_pow(x, r / 2) % mod;
ll k = mod_mul(t, t);
return (k % mod) * (x % mod);
}
}
ll mod_add(ll a, ll b)
{
return ((a % mod) + (b % mod)) % mod;
}
ll mod_mul(ll a, ll b)
{
return ((a % mod) * (b % mod)) % mod;
}
ll mod_div(ll a, ll b)
{
return mod_mul(a, mod_pow(b, mod - 2));
}
void fact_init()
{
make_fact(FACSIZE - 1);
make_invfact(FACSIZE);
}
void make_fact(ll n)
{
fac[0] = 1;
rep(i, n)
{
fac[i + 1] = mod_mul(fac[i], i + 1);
}
}
void make_invfact(ll n)
{
invfac[n] = mod_pow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--)
{
invfac[i] = mod_mul(invfac[i + 1], i + 1);
}
}
ll comb(ll n, ll r)
{
return mod_mul(mod_mul(fac[n], invfac[r]), invfac[n - r]);
}
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
ll qp(ll a, ll b)
{
ll ans = 1LL;
do
{
if (b & 1LL)
ans = 1LL * mod_mul(ans, a) % mod;
a = 1LL * mod_mul(a, a) % mod;
} while (b >>= 1LL);
return ans;
}
ll qp(ll a, ll b, ll mo)
{
ll ans = 1LL;
do
{
if (b & 1LL)
ans = 1LL * (ans % mo) * (a % mo);
a = 1LL * (a % mo) * (a % mo);
} while (b >>= 1LL);
return ans;
}
ll gcd(ll a, ll b)
{
return b ? gcd(b, a % b) : a;
}
ll powLL(ll x, ll y)
{
ll ans = 1LL;
for (ll i = 0LL; i < y; i++)
ans *= x;
return ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O0")
typedef long long int ll;
typedef long double ld;
#define rep(i,n) for (ll i = 0; i < (n); ++i)
const ll mod = 1e9+7;
const ll INF = 1e18;
#define All(a) (a).begin(),(a).end()
#define Pi acos(-1)
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << setprecision(15) << fixed;
chrono::system_clock::time_point start,end;
start = chrono::system_clock::now();
ll n;
cin >> n;
vector<ll> a;
ll cnt = 0;
if (n == 0) {
cout << 0 << '\n';
return 0;
}
for (ll i = 0; n != 0; i++) {
a.push_back(n % -2);
if (a[i] == -1) {
a[i] = 1;
n = (n-1)/-2;
}
else n = n / -2;
++cnt;
}
rep(i,cnt) cout << a[cnt-i-1];
end = chrono::system_clock::now();
auto elapsed = chrono::duration_cast< chrono::milliseconds >(end - start).count();
cerr << elapsed << "ms" << '\n';
} | #include <bits/stdc++.h>
using namespace std;
int n, base(-2);
string s;
int main(){
cin >> n;
if (n == 0) cout << "0";
while (n != 0){
int r = n % base;
r += (r < 0? 2 : 0);
s += (n % base == 0 ? "0" : "1");
n = (n - r) / base;
}
reverse(s.begin(), s.end());
cout << s << endl;
}
| 1 |
#include<bits/stdc++.h>
#define pir pair<int,int>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
#define rsort(x,y) sort(x,y),reverse(x,y)
#define fr first
#define se second
using namespace std;
typedef long long ll;
const int Maxn=4100000;
const int inf=0x3f3f3f3f;
int n,x[Maxn],y[Maxn],dir[Maxn],bj[Maxn];
vector<pir> v[Maxn];
int getadir() {
char ch=getchar();
while(!isalpha(ch)) ch=getchar();
switch(ch) {
case 'U' : return 0;
case 'R' : return 1;
case 'D' : return 2;
case 'L' : return 3;
}
}
signed main() {
// freopen("test.in","r",stdin);
scanf("%d",&n);
for(int i=1;i<=n;i++) {
scanf("%d%d",&x[i],&y[i]);
dir[i]=getadir();
}
int ans=inf;
for(int i=1;i<=n;i++) if((dir[i]&1)==0) v[x[i]].push_back(make_pair(y[i],i)),bj[x[i]]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int temp=0;
for(pir j:v[i]) {
if(dir[j.se]==2) {
if(temp) qmin(ans,j.fr-y[temp]);
}
else temp=j.se;
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
for(int i=1;i<=n;i++) if(dir[i]&1) v[y[i]].push_back(make_pair(x[i],i)),bj[y[i]]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int temp=0;
for(pir j:v[i]) {
if(dir[j.se]==3) {
if(temp) qmin(ans,j.fr-x[temp]);
}
else temp=j.se;
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
for(int i=1;i<=n;i++) v[x[i]+y[i]].push_back(make_pair(x[i],i)),bj[x[i]+y[i]]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int tempx=0,tempy=0;
for(pir j:v[i]) {
if(dir[j.se]==0) {
if(tempy) qmin(ans,(j.fr-x[tempy])*2);
}
else if(dir[j.se]==1) tempy=j.se;
else if(dir[j.se]==2) tempx=j.se;
else if(tempx) qmin(ans,(j.fr-x[tempx])*2);
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
for(int i=1;i<=n;i++) v[x[i]-y[i]+2000000].push_back(make_pair(x[i],i)),bj[x[i]-y[i]+2000000]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int tempx=0,tempy=0;
for(pir j:v[i]) {
if(dir[j.se]==3) {
if(tempy) qmin(ans,(j.fr-x[tempy])*2);
}
else if(dir[j.se]==0) tempy=j.se;
else if(dir[j.se]==1) tempx=j.se;
else if(tempx) qmin(ans,(j.fr-x[tempx])*2);
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
if(ans==inf) return 0*puts("SAFE");
ans*=5;
printf("%d\n",ans);
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 = 1e16;
#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(int i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;
const ll N = 2e5 + 10;
ll n, x[N], y[N];
char c[N];
map<ll, set<ll>> l, r, u, d;
int main(){
cin.tie(0); ios::sync_with_stdio(false);
cin >> n;
zep(i, 0, n)cin >> x[i] >> y[i] >> c[i];
ll ans1 = INF;
zep(i, 0, n){
if(c[i] == 'L')l[y[i]].insert(x[i]);
if(c[i] == 'D')u[x[i]].insert(y[i]);
}
zep(i, 0, n){
if(c[i] == 'R' && l.find(y[i]) != l.end()){
if(l[y[i]].lower_bound(x[i]) != l[y[i]].end()){
ans1 = min(ans1, (*l[y[i]].lower_bound(x[i])) - x[i]);
}
}
if(c[i] == 'U' && u.find(x[i]) != u.end()){
if(u[x[i]].lower_bound(y[i]) != u[x[i]].end()){
ans1 = min(ans1, (*u[x[i]].lower_bound(y[i])) - y[i]);
}
}
}
ans1 *= 5;
while(!l.empty())l.erase(l.begin());
while(!u.empty())u.erase(u.begin());
ll ans2 = INF;
zep(i, 0, n){
if(c[i] == 'L')l[x[i] - y[i]].insert(y[i]);
if(c[i] == 'D')d[x[i] - y[i]].insert(y[i]);
}
zep(i, 0, n){
if(c[i] == 'U' && l.find(x[i] - y[i]) != l.end()){
if(l[x[i] - y[i]].lower_bound(y[i]) != l[x[i] - y[i]].end()){
ans2 = min(ans2, (*l[x[i] - y[i]].lower_bound(y[i])) - y[i]);
}
}
}
zep(i, 0, n){
if(c[i] == 'R' && d.find(x[i] - y[i]) != d.end()){
if(d[x[i] - y[i]].lower_bound(y[i]) != d[x[i] - y[i]].end()){
ans2 = min(ans2, (*d[x[i] - y[i]].lower_bound(y[i])) - y[i]);
}
}
}
while(!l.empty())l.erase(l.begin());
while(!d.empty())d.erase(d.begin());
zep(i, 0, n){
if(c[i] == 'R')r[x[i] + y[i]].insert(y[i]);
if(c[i] == 'D')d[x[i] + y[i]].insert(y[i]);
}
zep(i, 0, n){
if(c[i] == 'U' && r.find(x[i] + y[i]) != r.end()){
if(r[x[i] + y[i]].lower_bound(y[i]) != r[x[i] + y[i]].end()){
ans2 = min(ans2, (*r[x[i] + y[i]].lower_bound(y[i])) - y[i]);
}
}
}
zep(i, 0, n){
if(c[i] == 'L' && d.find(x[i] + y[i]) != d.end()){
if(d[x[i] + y[i]].lower_bound(y[i]) != d[x[i] + y[i]].end()){
ans2 = min(ans2, (*d[x[i] + y[i]].lower_bound(y[i])) - y[i]);
}
}
}
ans2 *= 10;
ll ans = min(min(ans1, ans2), INF);
if(ans == INF){
print("SAFE")
}else{
print(ans)
}
return 0;
} | 1 |
#include<stdio.h>
#include<stdlib.h>
int Partition(int a[],int p,int r) {
int x = a[r];
int i = p - 1;
for (int j = p; j < r; j++) {
if (a[j] <= x) {
i++;
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
a[r] = a[i + 1];
a[i + 1] = x;
return i + 1;
}
int main() {
int n = 0;
int A[100005];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
int q = Partition(A, 0, n - 1);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
if (i == q) {
printf("[%d]", A[i]);
}
else {
printf("%d", A[i]);
}
}
printf("\n");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e16
#define mod 1000000007
void add(vector<ll>& vs, ll a){
for(ll v : vs){
minch(a,(a^v));
}
if(a!=0){
vs.push_back(a);
sort(all(vs)); reverse(all(vs));
}
}
bool is_contain(const vector<ll>& vs, ll a){
for(ll v : vs){
minch(a,(a^v));
}
return (a==0);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin>>T;
while(T--){
int N;
cin>>N;
vector<ll> A(N);
rep(i,N)cin>>A[i];
string S;
cin>>S;
vector<ll> dp;
dp.push_back(0);
bool ok=true;
for(ll i=N-1;i>=0;i--){
if(S[i]=='0'){
add(dp,A[i]);
}else{
if(!is_contain(dp,A[i]))ok=false;
}
}
if(ok)cout<<"0\n";
else cout<<"1\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int numOf1s(ll bit){
int cnt = 0;
while(bit){
if(bit & 1 == 1) ++cnt;
bit = bit >> 1;
}
return cnt;
}
int main(){
int N; cin >> N;
vector<vector<P>> vec(N);
rep(i, N){
int a; cin >> a;
rep(j, a){
int x,y; cin >> x >> y;
--x;
vec[i].push_back(P(x,y));
}
}
int result = 0;
for(ll bit=0; bit < (1<<N); ++bit){
bool valid = true;
for(int i=0; i<N; ++i){
if((bit >> i & 1) != 1) continue;
for(auto p : vec[i]){
if(p.second != (bit >> p.first & 1)){
valid = false;
}
}
}
if(valid) result = max(result, numOf1s(bit));
}
cout << result << endl;
}
| #include<iostream>
#include<vector>
#include<algorithm>
#include<cctype>
#include<utility>
#include<string>
#include<cstdio>
#define REP(n) for(int i = 0;i < n;i++)
#define LLREP(n) for(long long int i = 0;i < n;i++)
typedef long long int ll;
using namespace std;
#define MAX_A 1000000007
int main(){
string s;
int tmp = 0;
while(getline(cin,s)){
for(int i = 0;i < 26;i++){
string tmp(s);
for(int j = 0;j < s.length();j++){
if(isalpha(s[j])){
tmp[j] = (s[j]-'a'+i)%26 + 'a';
}
}
if(tmp.find("the")!=-1||tmp.find("this")!=-1||tmp.find("that")!=-1) {
cout << tmp << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
long long INF = (1LL<<62);
string X;
int main(int argc, char* argv[]){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> X;
string s;
for(int i=0; i<X.size(); i++){
if(i == 0){
s.push_back(X[i]);
}
else{
if(s[s.size()-1] == 'S' && X[i] == 'T'){
s.pop_back();
}
else{
s.push_back(X[i]);
}
}
}
printf("%d\n", (int)s.size());
return 0;
} | #include<iostream>
#include<string>
#include<numeric>
#include<set>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
typedef long long li;
#define minimize(a,b) (a>(b)?a=(b),1:0)
#define maximize(a,b) (a<(b)?a=(b),1:0)
#define ceil(a,b) (((a)+(b)-1)/(b))
#define yn(i) ((i)?"Yes":"No")
#define chmin(a,b) (a>(b)?a=(b),1:0)
#define abs(n) max((n),-(n))
#define dist(a,b) max((a)-(b),(b)-(a))
#define chmax(a,b) (a<(b)?a=(b),1:0)
#define repa(i,a,n) for(int i=(a);i<(n);i++)
#define MOD 1000000000
#define rep(i,n) for(int i=0;i<(n);i++)
#define df 0
template<class T> void print(const T& t){ cout << t << "\n"; }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) { cout << t; if (sizeof...(ts)) cout << " "; print(ts...); }
// Container コンテナ型, map以外
template< template<class ...> class Ctn,class T>
std::ostream& operator<<(std::ostream& os,const Ctn<T>& v){
auto itr=v.begin();
while(itr!=v.end()){
if(itr!=v.begin())cout << " ";
cout << *(itr++);
}
return os;
}
string key="keyence";
void add(char m,string s,set<string> st){
int n=s.size();
rep(i,n){
if(s[i]!=m) continue;
string t;
repa(j,i,n){
t.push_back(s[j]);
st.insert(t);
}
}
}
int gcd(int a,int b){
return b?gcd(b,a%b):a;
}
int main(){
string s; cin >>s;
int d=0,ans=0,n=s.size();
rep(i,n){
if(s[i]=='S'){
d+=1; continue;
}
if(d>0){
d-=1; continue;
}
ans++;
}
print(ans+d);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string hands( const vector<int>& c ) {
int n = (int)c.size();
int p1 = 0;
int c3 = 0;
for( int i = 0; i < n; ++i ) {
if( c[i] == 4 ) {
return "four card";
}
else if( c[i] == 3 ) { c3 += 1; }
else if( c[i] == 2 ) { p1 += 1; }
}
if( c3 > 0 && p1 > 0 ) {
return "full house";
}
else if( c3 > 0 ) {
return "three card";
}
else if( p1 == 2 ) {
return "two pair";
}
else if( p1 == 1 ) {
return "one pair";
}
int x = 0;
for( int i = 0; i <= n; ++i ) {
x = (c[i%n] == 1) ? (x+1) : 0;
if( x == 5 ) { break; }
}
return x == 5 ? "straight" : "null";
}
int main() {
ios_base::sync_with_stdio( false );
string line;
while( getline( cin, line ) ) {
replace( line.begin(), line.end(), ',', ' ' );
istringstream iss( line );
vector<int> cnt( 13 );
int cd;
while( iss >> cd ) { cnt[cd-1] += 1; }
cout << hands( cnt ) << '\n';
}
return 0;
}
| #include <stdio.h>
int main(){
int x[5],i,j;
while(scanf("%d,%d,%d,%d,%d",&x[0],&x[1],&x[2],&x[3],&x[4])!=EOF){
for(j=0;j<5;j++){
for(i=0;i<4;i++){
if(x[i]>x[i+1]){
int g=x[i+1];
x[i+1]=x[i];
x[i]=g;
}}}
if(x[0]==x[1] && x[1]==x[2] && x[2]==x[3]){
printf("four card\n");
continue;
}
if(x[1]==x[2] &&x[2]==x[3]&&x[3]==x[4]){
printf("four card\n");
continue;
}
if(x[0]==x[1]&&x[1]==x[2]&&x[3]==x[4]){
printf("full house\n");
continue;
}
if(x[0]==x[1]&&x[2]==x[3]&&x[3]==x[4]){
printf("full house\n");
continue;
}
if(x[0]<=10 && x[0]+1==x[1]&&x[1]+1==x[2]&&x[2]+1==x[3]&&x[3]+1==x[4]){
printf("straight\n");
continue;
}
if(x[0]==1&&x[1]==10&&x[2]==11&&x[3]==12&&x[4]==13){
printf("straight\n");
continue;
}
if(x[0]==x[1]&&x[1]==x[2]){
printf("three card\n");
continue;
}
if(x[1]==x[2]&&x[3]==x[2]){
printf("three card\n");
continue;
}
if(x[2]==x[3]&&x[3]==x[4]){
printf("three card\n");
continue;
}
if(x[0]==x[1] && x[2]==x[3]){
printf("two pair\n");
continue;
}
if(x[0]==x[1] && x[2]==x[3]){
printf("two pair\n");
continue;
}
if(x[0]==x[1]&&x[3]==x[4]){
printf("two pair\n");
continue;
}
if(x[1]==x[2]&&x[3]==x[4]){
printf("two pair\n");
continue;
}
if(x[0]==x[1]){
printf("one pair\n");
continue;
}
if(x[2]==x[1]){
printf("one pair\n");
continue;
}
if(x[2]==x[3]){
printf("one pair\n");
continue;
}
if(x[3]==x[4]){
printf("one pair\n");
continue;
}
printf("null\n");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
//定数
//円周率
const double pi = 3.141592653589793238462643383279;
//天井
const int INF = 1000000000; // = 10^9
const ll LINF = 100000000000000000; // = 10^17
//ABC文字列
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZABC";
const string abc = "abcdefghijklmnopqrstuvwxyzabc";
//よくあるmodくん
const ll MOD = 1000000007; // = 10^9 + 7
//前処理テーブルの大きさ指定
const int MAX = 1200000; // = 10^6 + 2*(10^5)
//ちなみに、1024MBで持てる最大長の配列は10^8程度
//データ構造
//隣接リスト用構造体（有向グラフ向け）
struct edge {
ll to; // E.toでその辺の終点へアクセスできる。
ll cost; // e.costでその辺の重みにアクセスできる。
};
//Union_Find木
struct UnionFind {
vector<int> UF; // UF.at(i) : iの親の番号
vector<int> SIZE; // SIZE.at(root(i)) : iと連結されてる要素の数
UnionFind(int N) : UF(N), SIZE(N, 1) { // 最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) {
UF.at(i) = i;
}
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (UF.at(x) == x) {
return x;
}
return UF.at(x) = root(UF.at(x));
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry) {
return; // xとyの根が同じ(=同じ木にある)時はそのまま
}
// xとyの根が同じでない(=同じ木にない)時：小さい方の根を大きい方の根につける。
if (SIZE.at(rx) < SIZE.at(ry)) {
UF.at(rx) = ry;
SIZE.at(ry) += SIZE.at(rx);
SIZE.at(rx) = 0;
}
else {
UF.at(ry) = rx;
SIZE.at(rx) += SIZE.at(ry);
SIZE.at(ry) = 0;
}
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す。
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x) { // xと連結されてる要素の数を返す。
return SIZE.at(root(x));
}
};
//関数 (計算量)
//ctoi (O(1))
int ctoi(char c){
if (c == '0') return 0;
if (c == '1') return 1;
if (c == '2') return 2;
if (c == '3') return 3;
if (c == '4') return 4;
if (c == '5') return 5;
if (c == '6') return 6;
if (c == '7') return 7;
if (c == '8') return 8;
if (c == '9') return 9;
return -1;
}
//to_char (O(1))
char to_char(int i){
if (i == 0) return '0';
if (i == 1) return '1';
if (i == 2) return '2';
if (i == 3) return '3';
if (i == 4) return '4';
if (i == 5) return '5';
if (i == 6) return '6';
if (i == 7) return '7';
if (i == 8) return '8';
if (i == 9) return '9';
return ' ';
}
// A^N mod M を計算する。modしたくなかったらM = LINFとかにすればよい。(O(√N))
ll modpow(ll A, ll N, ll M) {
ll ans = 1;
while (N > 0) {
if (N & 1) ans = ans * A % M;
A = A * A % M;
N >>= 1;
}
return ans;
}
//メイン処理
int main() {
cout << fixed << setprecision(16); //精度向上
//ここまでテンプレ
int N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
vector<vector<ll>> DP(N, vector<ll>(2, -LINF));
DP.at(0).at(0) = A.at(0);
for (int i = 1; i < N; i++) {
DP.at(i).at(0) = max(DP.at(i - 1).at(0), DP.at(i - 1).at(1)) + A.at(i);
DP.at(i).at(1) = max(DP.at(i - 1).at(0) - 2 * A.at(i - 1) - A.at(i),
DP.at(i - 1).at(1) + 2 * A.at(i - 1) - A.at(i));
}
cout << max(DP.at(N - 1).at(0), DP.at(N - 1).at(1)) << endl;
} | #include <iostream>
#define rep(i, n) for(int i=0; i<n; i++)
using namespace std;
int main(void){
int N;
cin >> N;
int A[N];
rep(i, N)
cin >> A[i];
// 入力終了
// A[]中の負の数の数
int negative_num = 0;
rep(i, N)
if(A[i] < 0)
negative_num++;
long long ans = 0;
// 負の数が偶数個なら，操作の繰り返しで全て正にできる
if(negative_num % 2 == 0){
rep(i, N)
ans += abs(A[i]);
}
// 奇数個なら，1つを残して全て正にできる
// 絶対値が一番小さいものを負にしておけばOK
else{
// 絶対値が一番小さいものを探す
int abs_min = 1000000000;
rep(i, N)
if(abs(A[i]) < abs_min)
abs_min = abs(A[i] );
// 絶対値が最小のもの以外は正で足す
// 絶対値が最小のものは負で足す
rep(i, N)
if(abs(A[i]) != abs_min)
ans += abs(A[i] );
else
ans -= abs(A[i] );
}
// 解答
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct Edge {
int src, dst;
Edge() : src(0), dst(0) {}
Edge(int s, int d) : src(s), dst(d) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
vector<int> kosaraju(const Graph &g) {
int n = g.size(), sz = 0; Graph rg(n);
vector<int> stk, cmp(n, -1), added(n), visited(n), ord(n);
for(auto &es : g) {
sz += es.size();
for(const Edge &e : es) rg[e.dst].emplace_back(e.dst, e.src);
}
stk.resize(n + sz); sz = 0;
for(int i = 0; i < n; i++) {
if(visited[i]) continue;
int s = 0; stk[s++] = i;
while(s != 0) {
int v = stk[s - 1]; visited[v] = true;
bool pushed = false;
for(auto &e : g[v]) {
int dst = e.dst;
if(!visited[dst]) { stk[s++] = dst; pushed = true; }
}
if(pushed) continue;
int t = stk[s - 1];
if(!added[t]) { added[t] = true; ord[n - ++sz] = t; }
--s;
}
}
int k = 0;
for(int &u : ord) {
if(cmp[u] != -1) continue;
int s = 0; stk[s++] = u;
while(s != 0) {
int v = stk[--s]; cmp[v] = k;
for(auto &e : rg[v]) {
int d = e.dst;
if(cmp[d] == -1) stk[s++] = d;
}
}
++k;
}
return cmp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E, Q;
cin >> V >> E;
Graph G(V);
for(int i = 0; i < E; i++) {
int u, v;
cin >> u >> v;
G[u].push_back({ u, v });
}
auto res = kosaraju(G);
cin >> Q;
while(Q--) {
int u, v;
cin >> u >> v;
cout << (res[u] == res[v]) << endl;
}
} | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> G[1000000];
vector<pair<int, int> > bridge;
vector<int> articulation;
int ord[1000000], low[1000000];
bool vis[1000000];
void dfs(int v, int p, int &k)
{
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
bool isArticulation = false;
int ct = 0;
for (int i = 0; i < G[v].size(); i++){
if (!vis[G[v][i]]){
ct++;
dfs(G[v][i], v, k);
low[v] = min(low[v], low[G[v][i]]);
if (~p && ord[v] <= low[G[v][i]]) isArticulation = true;
if (ord[v] < low[G[v][i]]) bridge.push_back(make_pair(min(v, G[v][i]), max(v, G[v][i])));
}
else if (G[v][i] != p){
low[v] = min(low[v], ord[G[v][i]]);
}
}
if (p == -1 && ct > 1) isArticulation = true;
if (isArticulation) articulation.push_back(v);
}
int main()
{
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++){
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
int k = 0;
for (int i = 0; i < n; i++){
if (!vis[i]) dfs(i, -1, k);
}
sort(bridge.begin(), bridge.end());
sort(articulation.begin(), articulation.end());
//printf("%d\n", articulation.size());
for (int i = 0; i < articulation.size(); i++)
printf("%d\n", articulation[i]);
//printf("%d\n", bridge.size());
/*for (int i = 0; i < bridge.size(); i++)
printf("%d %d\n", bridge[i].first + 1, bridge[i].second + 1);
*/
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 4e6 + 10, M = 2e3 + 10, MOD = 1e9 + 7;
int fac[N], inv[N], dp[M][M], ps[M][M];
int sum(int a, int b) {return (a + b) % MOD;}
int mul(int a, int b) {return (a * b) % MOD;}
int Pow(int a, int b)
{
int res = 1;
for (; b; b>>=1, a = mul(a, a)) if (b & 1) res = mul(res, a);
return res;
}
int C(int n, int k)
{
if (k < 0 || n < 0 || k > n) return 0;
return mul(fac[n], mul(inv[k], inv[n - k]));
}
int32_t main()
{
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = mul(fac[i - 1], i);
inv[N - 1] = Pow(fac[N - 1], MOD - 2);
for (int i = N - 2; i >= 0; i--) inv[i] = mul(inv[i + 1], i + 1);
int n, k; cin >> n >> k;
if (k == 1) return cout << "1\n", 0;
ps[1][1] = dp[1][1] = 1;
for (int i = 2; i <= n; i++) {
dp[i][1] = mul(ps[i - 1][1], C(i * k - 2, k - 2));
for (int j = 2; j <= i; j++) {
dp[i][j] = mul(ps[i - 1][j - 1], C(i * k - j - 1, k - 2));
}
for (int j = i; j >= 1; j--) ps[i][j] = sum(ps[i][j + 1], dp[i][j]);
}
cout << mul(ps[n][1], fac[n]) << "\n";
}
| #include<bits/stdc++.h>
#define ll long long
using namespace std;
template<typename T>
void read(T &x)
{
x=0;char c=getchar();bool p=0;
for(;c<'0'||c>'9';c=getchar())if(c=='-')p=1;
for(;c>='0'&&c<='9';c=getchar())x=(x<<3)+(x<<1)+(c^48);
if(p)x=-x;
}
const ll MOD=1000000000+7;
ll f[2005][2005];
ll fac[4000005],inv[4000005];
int n,k;
ll ksm(ll basic,ll mi)
{
ll tmp=1;
while(mi)
{
if(mi&1)tmp=tmp*basic%MOD;
mi>>=1;
basic=basic*basic%MOD;
}
return tmp;
}
ll C(ll x,ll y)
{
return fac[x]*inv[y]%MOD*inv[x-y]%MOD;
}
int main()
{
read(n),read(k);
fac[0]=inv[0]=1;
for(ll i=1;i<=n*k;++i)fac[i]=fac[i-1]*i%MOD;
inv[n*k]=ksm(fac[n*k],MOD-2);
for(ll i=n*k-1;i;--i)inv[i]=inv[i+1]*(i+1)%MOD;
if(k==1)
{
printf("1\n");
return 0;
}
f[0][0]=1;
for(int i=1;i<=n;++i)
{
f[i][0]=1;
for(int j=1;j<=i;++j)
{
f[i][j]=(f[i][j]+f[i-1][j]+1ll*f[i][j-1]*(n-j+1)%MOD*C(n*k-i-(j-1)*(k-1)-1,k-2)%MOD)%MOD;
}
}
printf("%lld\n",f[n][n]);
return 0;
} | 1 |
#include <iostream>
#include <iomanip>
#include <string>
typedef long long ll;
using namespace std;
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
#define repi(i, n, init) for(ll i=init;i<(n);i++)
int main() {
string s;
cin >> s;
if (s == "zyxwvutsrqponmlkjihgfedcba") {
cout << -1 << endl;
return 0;
}
bool c[26] = {false};
int n = s.size();
repi(i, n, 0) {
c[s[i] - 'a'] = true;
}
if (n == 26) {
for (int i = n - 1; i >= 0; i--) {
bool flag = false;
repi(j, 26, s[i] - 'a') {
if (!c[j]) {
if (i + 1 != n) {
s.erase(i);
}
s.push_back('a' + j);
flag = true;
break;
}
}
if (flag)break;
c[s[i] - 'a'] = false;
s.erase(i);
}
} else {
for (int i = n - 1; i >= 0; i--) {
bool flag = false;
repi(j, 26, 0) {
if (!c[j]) {
s.push_back('a' + j);
flag = true;
break;
}
}
if (flag)break;
}
}
cout << s << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
int alp[27];
for (int i = 0; i < 26; i++) {
alp[i] = 0;
}
alp[26] = 1;
cin >> s;
if (s == "zyxwvutsrqponmlkjihgfedcba") {
puts("-1");
} else {
string ans = "";
for (int i = 0; i < (int)s.size(); i++) {
alp[s[i] - 'a']++;
}
if (s.size() < 26) {
for (int i = 0; i < 26; i++) {
if (alp[i] == 0) {
ans = s + (char)('a' + i);
break;
}
}
} else {
string s_next = s;
next_permutation(s_next.begin(), s_next.end());
for (int i = 0; i < (int)s.size(); i++) {
ans += s_next[i];
if (s[i] != s_next[i]) break;
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define inf 0x3f3f3f3f
#define m_k make_pair
#define int long long
using namespace std;
const int N=1e5+100;
int n,m,k,a[N],b[N],f[N],c[N];
int fa[N][64],sum[N];
signed main()
{
scanf("%lld",&n);
for (int i=1;i<=n;i++) scanf("%lld",&f[i]);
scanf("%lld%lld",&m,&k);
for (int i=1;i<=m;i++) scanf("%lld",&a[i]);
for (int i=1;i<=n;i++) b[i]=i;
for (int i=1;i<=m;i++) swap(b[a[i]],b[a[i]+1]);
for (int i=1;i<=n;i++) fa[i][0]=b[i];
for (int j=1;j<=62;j++)
{
for (int i=1;i<=n;i++) fa[i][j]=fa[fa[i][j-1]][j-1];
}
for (int i=1;i<=n;i++)
{
int cnt=k,x=i;
for (int j=62;j>=0;j--)
{
if (cnt>=(1ll<<j))
{
cnt-=(1ll<<j);
x=fa[x][j];
}
}
if (x==1) c[i]=f[x];
else c[i]=f[x]-f[x-1];
}
for (int i=1;i<=n;i++) sum[i]=sum[i-1]+c[i];
for (int i=1;i<=n;i++)
{
double ans=sum[i];
printf("%.12lf\n",ans);
}
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define ii pair<int, int>
#define int long long
using namespace std;
const int INF = 1e9;
int n, m;
int ans = INF;
int a[85][85], b[85][85];
bool f[85][85][52000];
void attempt(int i, int j, int diff)
{
if (i == n && j == m)
{
ans = min(ans, abs(diff + a[i][j] - b[i][j]));
ans = min(ans, abs(diff - a[i][j] + b[i][j]));
return;
}
if (f[i][j][diff])
return;
f[i][j][diff] = 1;
if (i < n){
attempt(i+1, j, abs(diff + a[i][j] - b[i][j]));
attempt(i+1, j, abs(diff - a[i][j] + b[i][j]));
}
if (j < m){
attempt(i, j+1, abs(diff + a[i][j] - b[i][j]));
attempt(i, j+1, abs(diff - a[i][j] + b[i][j]));
}
}
int32_t main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("in.inp", "r", stdin);
// freopen("out.out", "w", stdout);
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> b[i][j];
attempt(1, 1, 0);
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
int a_01 = A / 10000;
int a_02 = A / 1000 - a_01 * 10;
int a_03 = A / 100 - a_01 * 100 - a_02 * 10;
int b_01 = B / 10000;
int b_02 = B / 1000 - b_01 * 10;
int b_03 = B / 100 - b_01 * 100 - b_02 * 10;
int head = 0, tail = 0;
if (A <= (a_01 * 10000 + a_02 * 1000 + a_03 * 100
+ a_02 * 10 + a_01)){
head = 1;
}
if (B >= (b_01 * 10000 + b_02 * 1000 + b_03 * 100
+ b_02 * 10 + b_01)){
tail = 1;
}
int sum;
if ((b_01 - a_01) >= 1){
sum = (b_01 - a_01 - 1) * 100
+ ((9 - a_02) + b_02) * 10
+ ((9 - a_03) + b_03)
+ head + tail;
}else{
if ((b_02 - a_02) >= 1){
sum = (b_02 - a_02 -1) * 10
+ ((9 - a_03) + b_03)
+ head + tail;
}else{
if ((b_03 - a_03) >= 1){
sum = (b_03 - a_03 -1) + head + tail;
}else{
if (head == 1 && tail == 1){
sum = 1;
}else{
sum = 0;
}
}
}
}
cout << sum << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int cnt = 0;
for (int i = a; i <= b; i++) {
if (i%10==i/10000 && i/10%10==i/1000%10) {
cnt += 1;
}
}
cout << cnt << endl;
} | 1 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
namespace IO {
template <typename _T>
inline bool read(_T& x) {
x = 0;
_T y = 1;
char c = getchar();
while ((c < '0' || '9' < c) && c != EOF) {
if (c == '-')
y = -1;
c = getchar();
}
if (c == EOF)
return false;
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getchar();
x *= y;
return true;
}
template <typename _T>
inline _T input() {
_T x = 0, y = 1;
char c = getchar();
while ((c < '0' || '9' < c) && c != EOF) {
if (c == '-')
y = -1;
c = getchar();
}
if (c == EOF)
return 0;
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getchar();
x *= y;
return x;
}
}; // namespace IO
using namespace IO;
namespace modular {
const int MOD = 1000000007;
inline int add(int x, int y) { return (x += y) >= MOD ? x -= MOD : x; }
inline void inc(int& x, int y) { (x += y) >= MOD ? x -= MOD : 0; }
inline int mul(int x, int y) { return 1LL * x * y % MOD; }
inline int qpow(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = mul(x, x))
if (y & 1)
ans = mul(ans, x);
return ans;
}
}; // namespace modular
#define MAX_N 2000007
#define reg register
#define FIN(s) freopen(s, "r", stdin)
#define FOUT(s) freopen(s, "w", stdout)
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define rep(i, l, r) for (int i = l; i <= r; ++i)
#define lep(i, l, r) for (int i = l; i < r; ++i)
#define irep(i, r, l) for (int i = r; i >= l; --i)
#define ilep(i, r, l) for (int i = r; i > l; --i)
typedef long long ll;
int N;
char s[MAX_N], t[MAX_N];
std::queue<int> q;
inline void solve() {
int j = N, tag = 0, ans = 0, las = N + 1;
irep(i, N, 1) {
while (j && (s[j] != t[i] || j > i))
j--;
if (!j)
return puts("-1"), void();
if (las == j) {
while (!q.empty() && q.front() - tag >= i)
q.pop();
} else {
tag++;
if (i != j) {
while (!q.empty() && q.front() - tag > i)
q.pop();
q.push(j + tag);
ans = std::max(ans, (int)q.size());
}
}
las = j;
}
printf("%d\n", ans);
}
int main() {
#ifdef LOCAL
FIN("in");
#endif
read(N);
scanf("%s%s", s + 1, t + 1);
rep(i, 1, N) if (s[i] != t[i]) {
solve();
return 0;
}
puts("0");
return 0;
} | #include <bits/stdc++.h>
#define debug(...) fprintf(stderr, __VA_ARGS__)
using namespace std;
void read(int&a) {
a = 0; char k = getchar(); int f = 1;
for(;!isdigit(k); k = getchar()) if (k == '-') f = -1;
for(; isdigit(k); k = getchar()) a = a * 10 + k - '0';
a *= f;
}
const int N = 1e6 + 5;
int n, a[N], b[N], flag = true;
char s[N];
queue<int> Q;
int main()
{
scanf("%d", &n);
scanf("%s", s); for(int i = 0; i < n; ++i) a[i] = s[i] - 'a' + 1;
scanf("%s", s); for(int i = 0; i < n; ++i) b[i] = s[i] - 'a' + 1, flag &= b[i] == a[i];
int s = n - 1, t = n - 1;
if(flag) {
printf("0\n");
return 0;
}
int ans = 1;
while(t >= 0) {
while(t > 0 && b[t] == b[t - 1]) t -= 1;
while(s >= 0 && (s > t || a[s] != b[t])) s -= 1;
if(s < 0) {
printf("-1\n");
return 0;
}
while(Q.size() && Q.front() - Q.size() >= t) Q.pop();
if(s != t) Q.push(s);
ans = max(ans, (signed)Q.size() + 1);
--t;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
int h,w,n;
template<typename int_t>
void readx(int_t &x)
{
x=0; int_t k=1; char ch=0;
while (ch<'0' || ch>'9') { ch=getchar(); if (ch=='-') k=-1; }
while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); }
x*=k;
}
int main()
{
readx(h); readx(w); readx(n);
if (h<w) swap(h,w);
printf("%d\n", (n/h) + (bool)(n%h) );
return 0;
} | #include<stdio.h>
int main(){
int h, w, n, ans;
scanf("%d", &h);
scanf("%d", &w);
scanf("%d", &n);
if(w>=h){
if(n%w == 0){
ans = n/w;
}else if(n%w != 0){
ans = n/w+1;
}
}else if(w<=h){
if(n%h == 0){
ans = n/h;
}else if(n%h != 0){
ans = n/h+1;
}
}
printf("%d", ans);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int getDivCount(int);
int main()
{
int N, A, tmp = 0;
int res = 1;
cin >> N;
for (int i = 0; i < N; ++i)
{
cin >> A;
tmp = getDivCount(A);
if (tmp == 0)
{
cout << tmp << endl;
return 0;
}
res = i == 0 ? tmp : res > tmp ? tmp : res;
}
cout << res << endl;
}
int getDivCount(int num)
{
int count = 0;
while (num % 2 == 0)
{
num /= 2;
++count;
}
return count;
}
| #include <iostream>
#include <cstdio>
using namespace std;
int main(void){
int copy,n;
cin >>n;
for(int i=1;i<=n;i++){
if(i%3==0){
cout << " " << i;
continue;
}
copy=i;
while(1){
if (copy%10==3){
cout << " " << i;
break;
}
copy/=10;
if(copy!=0)
continue;
else
break;
}
}
cout << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
#define mo 1000000007
#define ny 499122177
#define maxn 1000000000000000000LL
#define pi 3.1415926535898
#define eps 1e-9
using namespace std;
long long read(){
long long xx=0,flagg=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')
ch=getchar();
if(ch=='-'){
flagg=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
xx=xx*10+ch-'0';
ch=getchar();
}
return xx*flagg;
}
void pus(long long xx,long long flagg){
if(xx<0){
putchar('-');
xx=-xx;
}
if(xx>=10)
pus(xx/10,0);
putchar(xx%10+'0');
if(flagg==1)
putchar(' ');
if(flagg==2)
putchar('\n');
return;
}
int n,m,d1,d2,i,j,flag,cnt,book[605][605];
void ss(int x){
flag=0;
while((x&3)==0){
x>>=2;
flag++;
}
if(x&1){
for(i=0;i<m;i++)
for(j=0;j<m;j++)
if(((i>>flag)+(j>>flag))&1)
book[i][j]=1;
}
else{
for(i=0;i<m;i++)
for(j=0;j<m;j++)
if((i>>flag)&1)
book[i][j]=1;
}
}
int main(){
// freopen("number.in","r",stdin);
// freopen("number.out","w",stdout);
n=read();d1=read();d2=read();
m=n*2;
ss(d1);
ss(d2);
for(i=0;i<m;i++)
for(j=0;j<m;j++){
if(book[i][j]==0){
pus(i,1);
pus(j,2);
cnt++;
}
if(cnt==n*n)
return 0;
}
return 0;
} | #include <iostream>
#include <fstream>
using namespace std;
const int nmax=100005;
int p[nmax],viz[nmax],cyc[nmax],newp[nmax];
long long x[nmax],dif[nmax];
long long k,nr;
int n,i,j,xx,m;
int main()
{
//freopen("data.in","r",stdin);
ios_base::sync_with_stdio(false);
cin>>n;
for(i=1;i<=n;i++)
{
cin>>x[i];
}
for(i=1;i<n;i++)
dif[i]=(x[i+1]-x[i]),p[i]=i;
cin>>m>>k;
for(i=1;i<=m;i++)
{
cin>>xx;
swap(p[xx-1],p[xx]);
}
for(i=1;i<n;i++)
if(!viz[i])
{
nr=0;xx=i;
while(!viz[xx])
{
viz[xx]=1;
cyc[nr++]=xx;
xx=p[xx];
}
long long md=(k)%nr;
for(j=0;j<nr;j++)
newp[cyc[j]]=(cyc[(j+md)%nr]);
}
for(i=1;i<=n;i++)
{
if(i>1)x[i]=x[i-1]+dif[newp[i-1]];
cout<<x[i]<<'\n';
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
struct edge{
int y,nxt,v;
}e[2000010];
set<int>c[2000010];
int n,m,head[2000010],dis[2000010],vis[2000010],tot;
void add(int x,int y,int v){
e[++tot]=edge{y,head[x],v};
head[x]=tot;
}
void dijkstra(){
priority_queue<pair<int,int> >q;
memset(dis,0x3f3f3f3f,sizeof(dis));
dis[1]=0; q.push(make_pair(0,1));
while(q.size()){
int x=q.top().second; q.pop();
if(vis[x]) continue; vis[x]=1;
// cout<<x<<':'<<dis[x]<<endl;
for(int i=head[x];i;i=e[i].nxt){
int y=e[i].y,v=c[x].count(e[i].v)?0:1;
// cout<<"y = "<<y<<endl;
if(dis[x]+v<dis[y]){
dis[y]=dis[x]+v;
q.push(make_pair(-dis[y],y));
c[y].clear(); c[y].insert(e[i].v);
}
else if(dis[x]+v==dis[y]) c[y].insert(e[i].v);
}
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
int x,y,v;
scanf("%d%d%d",&x,&y,&v);
add(x,y,v); add(y,x,v);
}
dijkstra();
// cout<<0x3f3f3f3f3f<<endl;
if(dis[n]==0x3f3f3f3f) printf("-1");
else printf("%d",dis[n]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
// 入力
int N, Q;
cin >> N >> Q;
vector<int> S(N), T(N), X(N);
for (int i = 0; i < N; i++) {
cin >> S.at(i) >> T.at(i) >> X.at(i);
}
vector<int> D(Q);
for (int i = 0; i < Q; i++) {
cin >> D.at(i);
D[i] = D[i];
}
// イベント
vector<tuple<int, int, int>> event;
for (int i = 0; i < N; i++) {
event.push_back(make_tuple(S[i] - X[i], 1, X[i])); // 通行止め開始イベント
event.push_back(make_tuple(T[i] - X[i], -1, X[i])); // 通行止め終了イベント
}
sort(event.begin(), event.end()); // 時系列順に並べる
set<int> se; // 現在出発した人が当たる可能性のある通行止めの情報を保存する set
vector<int> ans(Q);
int t = 0;
int id = 0;
for (int i = 0; i < Q; i++) {
t = D[i];
for (; id < (int)event.size() && get<0>(event[id]) <= t; id++) {
if (get<1>(event[id]) == 1) {
se.insert(get<2>(event[id]));
} else {
se.erase(get<2>(event[id]));
}
}
if (se.empty()) {
ans[i] = -1;
} else {
ans[i] = *se.begin();
}
}
for (int i = 0; i < Q; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 0 |
#include "bits/stdc++.h"
#include <cstdio>
#include <cmath>
using namespace std;
int main(){
int d=0;
while(cin>>d){
int sum=0;
for (int i = 0; i < 600; i=i+d) {
sum+=i*i*d;
}
cout<<sum<<endl;
}
} | #include <bits/stdc++.h>
//const static double de_PI = 3.14159265358979323846;
//const static int de_MOD = 1000000007;
//const static int de_MAX = 999999999;
//const static int de_MIN = -999999999;
int main(void) {
//std::ifstream in("123.txt"); std::cin.rdbuf(in.rdbuf());
double n = 0;
std::vector<double> ans;
while (std::cin >> n) {
double sum = 0;
double div = 600 / n;
for (int i = 1; i < div; i++) {
sum += n*(n*i)*(n*i);
}
ans.push_back(sum);
}
std::for_each(ans.begin(), ans.end(), [](int i) {std::cout << i << std::endl; });
} | 1 |
#include <bits/stdc++.h>
// statics
using namespace std;
using int64 = long long;
using PAIR = pair<int, int>;
constexpr int INF = 1 << 30;
constexpr int64 LINF = 1LL << 60;
constexpr int MOD = 1e9 + 7;
constexpr int MAX_N = 1e5 + 1;
// init/input
#define int int64
#define INIT ios::sync_with_stdio(false);cin.tie(0);
#define VAR(type, ...) type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T &t) {cin>>t;}
template<typename First, typename...Rest> void MACRO_VAR_Scan(First &first, Rest&...rest) {cin>>first;MACRO_VAR_Scan(rest...);}
#define VEC(type, c, n) vector<type> c(n);for(auto &&i:c)cin>>i;
// out
#define OUT(dist) cout<<(dist);
#define FOUT(n, dist) cout<<fixed<<setprecision(n)<<(dist);
#define SP cout<<" ";
#define BR cout<<"\n";
#define debug(x) cerr << #x << ":" << (x);BR;
// utility
#define ALL(a) (a).begin(), (a).end()
#define EACH(i, a) for(auto &&i:(a))
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=0;--i)
#define REP(i, n) for(int i=0;i<(n);++i)
#define RREP(i, n) for(int i=(n)-1;i>=0;--i)
signed main() {
INIT;
VAR(int, k);
int n = 50, p = k / n, q = k % n;
vector< int > a(n, n + p - q - 1);
REP(i, q) {
a[i] += 51;
}
OUT(n)BR;
REP(i, n) {
OUT(a[i]);
if (i < n - 1) SP;
}
BR;
return 0;
}
| #include<bits/stdc++.h>
#define PI 3.141592653589
using namespace std;
using ll = long long;
template<typename T_char>
T_char ToUpper(T_char cX){return toupper(cX);}
int main(){
int n;
cin >> n;
while(1){
if(n%111 == 0) break;
n++;
}
cout << n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,s,e) for(int (i)=(s);(i)<(int)(e);(i)++)
#define REP(i,e) FOR(i,0,e)
#define RFOR(i,e,s) for(int (i)=(e)-1;(i)>=(int)(s);(i)--)
#define RREP(i,e) RFOR(i,e,0)
#define all(o) (o).begin(), (o).end()
#define psb(x) push_back(x)
#define mp(x,y) make_pair((x),(y))
typedef long long ll;
typedef pair<int, int> PII;
typedef priority_queue<int> PQI;
typedef priority_queue<PII> PQII;
const double EPS = 1e-10;
const int INF = 1e9;
const int N = 100;
int n;
int r[N], c[N];
int dp[N+1][N];
int main() {
scanf("%d ", &n);
REP(i,n) scanf("%d%d ", r+i, c+i);
REP(i,n+1) REP(j,n) dp[i][j] = INF;
REP(j,n) dp[1][j] = 0;
FOR(i,2,n+1) REP(j,n-i+1) FOR(k,1,i)
dp[i][j] = min(dp[i][j], dp[k][j] + r[j]*c[j+k-1]*c[i+j-1] + dp[i-k][j+k]);
printf("%d\n", dp[n][0]);
return 0;
} | #include <stdio.h>
int main(){
int n;
scanf("%d",&n);
while(n){
int a=0,b=0,aa,bb;
for(int i=n;i>0;i--){
scanf("%d %d",&aa,&bb);
if(aa>bb){
a+=aa+bb;
}else if(aa<bb){
b+=aa+bb;
}else{
a+=aa;
b+=bb;
}
}
printf("%d %d\n",a,b);
scanf("%d",&n);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,s,n) for (int i = (int)s; i < (int)n; i++)
#define ll long long
#define pb push_back
#define eb emplace_back
#define All(x) x.begin(), x.end()
#define Range(x, i, j) x.begin() + i, x.begin() + j
#define lbidx(x, y) lower_bound(x.begin(), x.end(), y) - x.begin()
#define ubidx(x, y) upper_bound(x.begin(), x.end(), y) - x.begin()
#define llbidx(x, y, z) lower_bound(x.begin(), x.end(), z) - lower_bound(x.begin(), x.end(), y) // 二要素間の距離
#define deg2rad(deg) ((((double)deg)/((double)360)*2*M_PI))
#define rad2deg(rad) ((((double)rad)/(double)2/M_PI)*(double)360)
#define Find(set, element) set.find(element) != set.end()
#define Decimal(x) printf("%.10f\n", x) // 小数点を10桁まで表示
// debug用
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
typedef pair<int, int> PI;
typedef pair<ll, ll> PLL;
int POWINT(int x, int n) {
int ret = 1;
rep(i, 0, n) ret *= x;
return ret;
};
ll POWLL(int x, int n) {
ll ret = 1;
rep(i, 0, n) ret *= x;
return ret;
};
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;
};
struct Q {
int l, r, id;
};
bool lessL(const Q &q1, const Q &q2) {
return q1.l < q2.l;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<Q> q(N);
int max_l = 0;
int min_r = 1e9+7;
int max_len = 0;
rep(i, 0, N) {
cin >> q[i].l >> q[i].r;
q[i].r++;
q[i].id = i;
if (q[i].l > max_l) {
max_l = q[i].l;
}
if (q[i].r < min_r) {
min_r = q[i].r;
}
max_len = max(q[i].r - q[i].l, max_len);
}
int ans = max_len + max(0, min_r - max_l);
int ans_min_r = 2e9+7;
int ans_max_l = 2e9+7;
vector<PI> a(N);
rep(i, 0, N) {
a[i].first = max(q[i].r - max_l, 0);
a[i].second = max(min_r - q[i].l, 0);
}
sort(All(a));
int mn = a[0].second;
rep(i, 1, N) {
ans = max(ans, mn + a[i].first);
mn = min(mn, a[i].second);
}
cout << ans << endl;
return 0;
};
| #include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
using P = pair<int,int>;
const ll INF = 1000100100100100100;
/* 大文字を小文字に変換 */
char tolower(char c) {return (c + 0x20);}
/* 小文字を大文字に変換 */
char toupr(char c) {return (c - 0x20);}
// if('A'<=s[i] && s[i]<='Z') s[i] += 'a'-'A';
/*
string s = "abcdefg"
s.substr(4) "efg"
s.substr(0,3) "abc"
s.substr(2,4) "cdef"
// イテレータ要素のインデックス
distance(A.begin(), itr);
*/
int main()
{
int n; cin >> n;
ll a[n];
rep(i,n) cin >> a[i];
ll dp[n][2];
rep(i,n) rep(j,2) dp[i][j] = 0;
dp[0][1] = -INF;
rep(i,n){
if(i == n-1){
dp[i+1][0] = max(dp[i][0]+a[i], dp[i][1]-a[i]);
dp[i+1][1] = -INF;
}
else{
dp[i+1][0] = max(dp[i][0]+a[i], dp[i][1]-a[i]);
dp[i+1][1] = max(dp[i][0]-a[i], dp[i][1]+a[i]);
}
}
cout << dp[n][0] << endl;
} | 0 |
#include <algorithm>
#include <cstdio>
static const size_t n_max = 200000;
static int S[n_max], L[n_max], R[n_max];
static long long c = 0;
void merge_sort(size_t i, size_t j) {
switch (j - i) {
case 0:
case 1:
break;
case 2:
if (S[i+1] < S[i]) {
c++;
std::swap(S[i], S[i+1]);
}
break;
default:
size_t k = (i + j) / 2;
merge_sort(i, k);
merge_sort(k, j);
std::copy(S + i, S + k, L);
std::copy(S + k, S + j, R);
for (size_t l = i, p = 0, q = 0;; l++) {
if (p < k - i && q < j - k) {
if (L[p] <= R[q])
S[l] = L[p++];
else {
c += k - i - p;
S[l] = R[q++];
}
} else if (p < k - i)
S[l]= L[p++];
else if (q < j - k)
S[l] = R[q++];
else
break;
}
break;
}
}
int main() {
size_t n;
scanf("%zu", &n);
for (size_t i = 0; i < n; i++)
scanf("%d", S + i);
merge_sort(0, n);
printf("%lld\n", c);
return 0;
} | /*************************************
* @contest: AGC041.
* @user_name: hkxadpall.
* @time: 2019-12-28.
* @language: C++.
* @upload_place: AtCoder.
*************************************/
#include <bits/stdc++.h>
using namespace std;
typedef signed char int8;
typedef unsigned char uint8;
typedef short int16;
typedef unsigned short uint16;
typedef int int32;
typedef unsigned uint32;
typedef long long int64;
typedef unsigned long long uint64;
template <typename Int>
inline Int read()
{
Int flag = 1;
char c = getchar();
while ((!isdigit(c)) && c != '-') c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline Int read(char &c)
{
Int flag = 1;
c = getchar();
while ((!isdigit(c)) && c != '-') c = getchar();
if (c == '-') flag = -1, c = getchar();
Int init = c & 15;
while (isdigit(c = getchar())) init = (init << 3) + (init << 1) + (c & 15);
return init * flag;
}
template <typename Int>
inline void write(Int x)
{
if (x < 0) putchar('-'), x = ~x + 1;
if (x > 9) write(x / 10);
putchar((x % 10) | 48);
}
template <typename Int>
inline void write(Int x, char nextch)
{
write(x);
putchar(nextch);
}
int n;
char a[1007][1007];
// bool col[1007];
int now = 0;
void set3(int i, int j) // sum = 1
{
a[i][j] = a[i][j + 1] = 'o';
a[i + 1][j + 2] = a[i + 2][j + 2] = 'p';
}
void set4(int i, int j) // sum = 3
{
a[i + 0][j + 0] = 'a'; a[i + 0][j + 1] = 'a'; a[i + 0][j + 2] = 'c'; a[i + 0][j + 3] = 'd';
a[i + 1][j + 0] = 'b'; a[i + 1][j + 1] = 'b'; a[i + 1][j + 2] = 'c'; a[i + 1][j + 3] = 'd';
a[i + 2][j + 0] = 'e'; a[i + 2][j + 1] = 'f'; a[i + 2][j + 2] = 'g'; a[i + 2][j + 3] = 'g';
a[i + 3][j + 0] = 'e'; a[i + 3][j + 1] = 'f'; a[i + 3][j + 2] = 'h'; a[i + 3][j + 3] = 'h';
}
void set5(int i, int j)
{
a[i + 0][j + 0] = 'a'; a[i + 0][j + 1] = 'a'; a[i + 0][j + 2] = 'b'; a[i + 0][j + 3] = 'b'; a[i + 0][j + 4] = 'c';
a[i + 1][j + 0] = 'd'; a[i + 1][j + 1] = 'e'; a[i + 1][j + 2] = 'e'; a[i + 1][j + 3] = '.'; a[i + 1][j + 4] = 'c';
a[i + 2][j + 0] = 'd'; a[i + 2][j + 1] = '.'; a[i + 2][j + 2] = '.'; a[i + 2][j + 3] = 'e'; a[i + 2][j + 4] = 'a';
a[i + 3][j + 0] = 'a'; a[i + 3][j + 1] = '.'; a[i + 3][j + 2] = '.'; a[i + 3][j + 3] = 'e'; a[i + 3][j + 4] = 'a';
a[i + 4][j + 0] = 'a'; a[i + 4][j + 1] = 'b'; a[i + 4][j + 2] = 'b'; a[i + 4][j + 3] = 'c'; a[i + 4][j + 4] = 'c';
}
void set7(int x, int y)
{
static const char tpr[7 + 3][7 + 3] = {
"aa..bba",
"b.cc..a",
"bc.dd..",
".cd.cc.",
"..dc..b",
"a..c..b",
"abb..aa",
};
for (int i = 0; i < 7; i++) {
strncpy(a[x + i] + y, tpr[i], 7);
}
}
void outputMat()
{
for (register int i = 0; i < n; i++) {
for (register int j = 0; j < n; j++) {
if (a[i][j]) putchar(a[i][j]);
else putchar('.');
}
putchar('\n');
}
}
int main()
{
n = read<int>();
if (n % 4 == 0) {
for (register int i = 0; i < n; i += 4) set4(i, i);
outputMat();
} else if (n % 3 == 0) {
for (register int i = 0; i < n; i += 3) set3(i, i);
outputMat();
} else if (n % 4 == 1 && n >= 5) {
for (int i = 0; i < n - 5; i += 4) set4(i, i);
set5(n - 5, n - 5);
outputMat();
} else if (n % 4 == 2 && n >= 10) {
for (int i = 0; i < n - 10; i += 4) set4(i, i);
set5(n - 10, n - 10);
set5(n - 5, n - 5);
outputMat();
} else if (n % 4 == 3 && n >= 7) {
for (int i = 0; i < n - 7; i += 4) set4(i, i);
set7(n - 7, n - 7);
outputMat();
} else puts("-1");
return 0;
} | 0 |
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
int main() {
int N, K; cin >> N >> K;
if (N % K == 0) cout << 0 << endl;
else cout << 1 << endl;
}
| /*
* Project: AtCoder Beginners Contest 105 A - AtCoder Crackers
* Author: toms74209200 <https://github.com/toms74209200>
*
* Created on 2020/06/16
* Copyright (c) 2020 toms74209200
*
* This software is released under the MIT License.
* http://opensource.org/licenses/mit-license.php
*/
#include <cstdio>
using namespace std;
int n, k;
void solve() {
int rem = n % k;
if (rem == 0)
printf("0\n");
else
printf("1\n");
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
solve();
} | 1 |
#include<stdio.h>
#include<string.h>
int main(){
int l[10],v1,v2,i;
double sure;
while(0<=scanf("%d",&l[0])){
for(i=1;i<10;i++){
scanf(",%d",&l[i]);
l[i]+=l[i-1];
}
scanf(",%d,%d",&v1,&v2);
sure=(double)v1/(double)(v1+v2)*(double)(l[9]);
for(i=0;i<10;i++){
if(sure<=l[i]){
printf("%d\n",i+1);
break;
}
}
}
return 0;
} | #include<iostream>
using namespace std;
int main(void)
{
int L[10];
int V[2];
char C[11];
while(cin >> L[0] >> C[0])
{
for(int i=1; i<10; i++)
cin >> L[i] >> C[i];
cin >> V[0] >> C[10] >> V[1];
int sum = 0;
for(int i=0; i<10; i++)
sum += L[i];
double col_point = 0;
col_point = ((double)sum)/((double)V[0]+V[1])*V[0];
int ruikei = 0;
for(int i=0; i<10; i++)
{
ruikei += L[i];
if(col_point <= ruikei)
{
cout << (i+1) << endl;
break;
}
}
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
#define int long long
using namespace std;
signed main() {
string S;
int w;
cin>>S>>w;
for(int i=0;i<S.size();i+=w){
cout<<S[i];
}
} | #include <iostream>
#include <string>
#include <stack>
#include <math.h>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <vector>
using namespace std;
int main()
{
string s,t;
cin >> s;
t = s;
for (int i = 0; i < s.size(); i++) {
t[i] = s[s.size() - i-1];
}
cout << t << endl;
} | 0 |
#include<bits/stdc++.h>
#define ll long long int
#define endl '\n'
#define M 1000000007
#define yes cout<<"YES\n"
#define no cout<<"NO\n"
#define f first
#define s second
#define b begin
#define e end
#define pb push_back
#define mp make_pair
#define FOR(i,a,b) for(i=a;i<b;i++)
#define RFOR(i,a,b) for(i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define itfr(it,x) for(it=x.begin();it!=x.end();it++)
#define flash ios_base::sync_with_stdio(false); cin.tie(NULL)
using namespace std;
int main()
{
flash;
//sieve();
ll T=1,n,m,k,x,y,z;
// cin>>T;
while(T--)
{
string a,b,c;
cin>>a>>b>>c;
n = a.length();
m = b.length();
k = c.length();
x = 0; y = 0; z = 0;
char cur = 'a';
while(x<=n&&y<=m&&z<=k)
{
if(cur=='a')
{
cur = a[x];
x++;
}
else if(cur=='b')
{
cur = b[y];
y++;
}
else
{
cur = c[z];
z++;
}
}
if(x>n)
cout<<'A';
else if(y>m)
cout<<'B';
else
cout<<'C';
cout<<endl;
}
}
| #include <algorithm>
#include <climits>
#include <iostream>
#include <vector>
#define MAX_V 100
#define INF LONG_MAX / 4
using namespace std;
typedef struct {
int to, cost;
} edge;
vector<edge> G[MAX_V];
long long d[MAX_V][MAX_V];
bool find_negative_cycle(int v) {
for (int i = 0; i < v; i++) {
if (d[i][i] < 0) return true;
}
return false;
}
void warshall_floyd(int v) {
for (int k = 0; k < v; k++) {
for (int i = 0; i < v; i++) {
if (d[i][k] == INF) continue;
for (int j = 0; j < v; j++) {
if (d[k][j] == INF) continue;
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
void init(int v) {
for (int i = 0; i < v; i++) {
for (int j = 0; j < v; j++) {
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
}
}
for (int i = 0; i < v; i++) {
for (int j = 0; j < G[i].size(); j++) {
d[i][G[i][j].to] = G[i][j].cost;
}
}
}
int main() {
int v, e;
cin >> v >> e;
for (int i = 0; i < e; i++) {
edge temp;
int s, t, d;
cin >> s >> t >> d;
temp.to = t;
temp.cost = d;
G[s].push_back(temp);
}
init(v);
warshall_floyd(v);
if (find_negative_cycle(v) == true) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
for (int i = 0; i < v; i++) {
for (int j = 0; j < v; j++) {
if (INF - 20000000 <= d[i][j] && d[i][j] <= INF) {
cout << "INF";
} else {
cout << d[i][j];
}
if (j < v - 1) {
cout << ' ';
} else {
cout << endl;
}
}
}
return 0;
} | 0 |
#include<algorithm>
#include<cstdio>
using namespace std ;
int sports[ 1000 + 1 ] ;
int cnt[ 1000 + 1 ] ;
int CNT[ 1000 + 1 ] ;
int cmp ;
int N ,M ;
int ans()
{
sort( cnt + 1 ,cnt + N + 1 ) ;
return ( find_if( CNT ,CNT + N + 1 ,[]( int cmpair ){ return cmpair == cnt[ N ] ; } ) - CNT ) ;
}
int main( void )
{
scanf( "%d %d" ,&N ,&M ) ;
int i ;
for( i = 1 ; i <= N ; ++i )
{
scanf( "%d" ,&cmp ) ;
sports[ i ] = cmp ;
}
for( i = 0 ; i < M ; ++i )
{
scanf( "%d" ,&cmp ) ;
++cnt[ ( find_if( sports + 1 ,sports + N + 1 ,[]( int cmpair){ return cmp >= cmpair ; } ) - sports ) ] ;
}
copy( cnt ,cnt + N + 1 ,CNT ) ;
printf( "%d\n" ,ans() ) ;
return 0 ;
} | #include<iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <cmath>
#include <set>
#include <string.h>
#include <functional>
using namespace std;
int a[1010];
int b[1010];
int c[1010];
int main()
{
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<m;i++){
cin>>b[i];
}
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(b[i]>=a[j]){
c[j]++;
break;
}
}
}
int max=0;int ans=-1;;
for(int i=0;i<n;i++){
if(c[i]>max){
max=c[i];
ans=i+1;
}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#include <functional>
#include <array>
#include <map>
#include <queue>
#include <time.h>
#include <limits.h>
#include <set>
#include <stack>
#include <random>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#define rep(i,s,n) for(int i = (s); (n) > i; i++)
#define REP(i,n) rep(i,0,n)
#define RANGE(x,a,b) (min(a,b) <= (x) && (x) <= max(a,b)) //hei
#define DUPLE(a,b,c,d) (RANGE(a,c,d) || RANGE(b,c,d) || RANGE(c,a,b) || RANGE(d,a,b))
#define INCLU(a,b,c,d) (RANGE(a,c,d) && (b,c,d))
#define PW(x) ((x)*(x))
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define MODU 1000000007LL
#define bitcheck(a,b) ((a >> b) & 1)
#define bitset(a,b) ( a |= (1 << b))
#define bitunset(a,b) (a &= ~(1 << b))
#define MP(a,b) make_pair((a),(b))
#define Manh(a,b) (abs((a).first-(b).first) + abs((a).second - ((b).second))
#define pritnf printf
#define scnaf scanf
#define itn int
#define PI 3.141592653589
#define izryt bool
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template<typename A, size_t N, typename T>
void Fill(A(&array)[N], const T & val) {
std::fill((T*)array, (T*)(array + N), val);
}
pll Dir[4] = {
{ -1 ,0 },{ 0 , 1 },{ 1 ,0 },{ 0 ,-1 }
};
//[a, b)
#define Getsum(ar, a,b) (ar[b] - ar[a])
#define INF 10000000000000000LL
#define chmax(a,b) a = max(a,b)
#define chmin(a,b) a = min(a,b)
struct Edge {
int from, to;
ll w;
bool operator<(const Edge& rhs) const {
return MP(w, MP(from, to)) < MP(rhs.w, MP(rhs.from, rhs.to));
}
};
typedef vector<set<Edge>> Graph;
struct Segtree {
};
signed main(void) {
int n, m;
cin >> n >> m;
vector<ll> a(n), b(m), upc(n * m + 1);
multiset<ll> aa, ba;
REP(i, n) {
cin >> a[i];
aa.insert(a[i]);
}
REP(i, m) {
cin >> b[i];
ba.insert(b[i]);
}
REP(i, n) {
REP(j, m) {
upc[min(a[i], b[j])]++;
}
}
for (int i = n * m; 1 <= i; i--)
upc[i - 1] += upc[i];
ll used = 0;
ll ans = 1;
for (int i = n * m; 1 <= i; i--) {
if (aa.count(i) > 1 || ba.count(i) > 1) {
cout << 0 << endl;
return 0;
}
if (aa.count(i)) {
if (!ba.count(i)) {
int cc = 0;
REP(j, m) {
cc += b[j] > i;
}
ans *= cc;
}
}
else if (ba.count(i)) {
if (!aa.count(i)) {
int cc = 0;
REP(j, n) {
cc += a[j] > i;
}
ans *= cc;
}
}
else {
ans *= upc[i] - used;
}
ans %= MODU;
used++;
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; i--)
const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;
int N, M;
int A[1010], B[1010];
int C[1010101];
int belongs_a(int n)
{
auto lb = lower_bound(A, A + N, n);
int i = lb - begin(A);
if (A[i] == n)
{
return i;
}
else
{
return -1;
}
}
int greater_num_a(int n)
{
auto lb = upper_bound(A, A + N, n);
int i = lb - begin(A);
return N - i;
}
int belongs_b(int m)
{
auto lb = lower_bound(B, B + M, m);
int i = lb - begin(B);
if (B[i] == m)
{
return i;
}
else
{
return -1;
}
}
int greater_num_b(int m)
{
auto lb = upper_bound(B, B + M, m);
int i = lb - begin(B);
return M - i;
}
int main()
{
cin >> N >> M;
rep(i, 0, N)
{
cin >> A[i];
}
rep(i, 0, M)
{
cin >> B[i];
}
sort(A, A + N);
sort(B, B + M);
rep(i, 1, N)
{
if (A[i - 1] == A[i])
{
cout << 0 << endl;
return 0;
}
}
rep(i, 1, M)
{
if (B[i - 1] == B[i])
{
cout << 0 << endl;
return 0;
}
}
ll ans = 1;
for (int i = N * M; i >= 1; i--)
{
int ba = belongs_a(i);
int bb = belongs_b(i);
if (ba >= 0 && bb >= 0)
{
continue;
}
else if (ba >= 0)
{
ans *= greater_num_b(i);
ans %= MOD;
}
else if (bb >= 0)
{
ans *= greater_num_a(i);
ans %= MOD;
}
else
{
ll p = greater_num_a(i) * greater_num_b(i) % MOD;
p = (p - (M * N - i) + MOD) % MOD;
ans *= p;
ans %= MOD;
}
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
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();}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.141592653589793238462643383279;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL<<60;
constexpr long long MOD = 1000000007; // 998244353
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
ll dp[1<<16], score[1<<16];
ll a[16][16];
ll rec(int S){
if(dp[S] != -1) return dp[S];
if(S == 0) return dp[S] = 0;
ll ret = score[S];
for(int T=S; T>0; T=T-1&S){
if(S==T) continue;
chmax(ret, rec(T) + rec(S^T));
}
return dp[S] = ret;
}
int main(void){
int N; cin >> N; REP(i,1<<N) dp[i] = -1;
REP(i,N)REP(j,N) cin >> a[i][j];
REP(S,1<<N){
REP(i,N)FOR(j,i+1,N) if(S>>i & S>>j & 1) score[S] += a[i][j];
}
ll ans = rec((1<<N)-1);
cout << ans << en;
return 0;
} | #include<bits/stdc++.h>
#ifdef _PRINTDEBUG
#include "lib/printdebug.hpp"
#else
#define printdebug(...) 1
#endif
#define MOD_1_000_000_007 (1000000007)
#define IINF (1<<28)
#define LINF (1LL<<60)
#define rep(i, n) REP(i, 0, (n))
#define repc(i, n) REPC(i, 0, (n))
#define REP(i, n, m) for (int i = (int)(n); i < (int)(m); i++)
#define REPC(i, n, m) for (int i = (int)(n); i <= (int)(m); i++)
#define REPCM(i, n, m) for (int i = (int)(n); i >= (int)(m); i--)
#define yesno(cond) YESNO((cond), "Yes", "No")
#define YESNO(cond, a, b) cout << ((cond) ? (a) : (b)) << "\n"
namespace solver {
using namespace std;
typedef long long ll;
int N, as[16][16];
ll sum[1<<16], dp[1<<16];
void init() {
cin >> N;
rep(i, N) rep(j, N) {
cin >> as[i][j];
}
}
void build_sum() {
rep(i, 1<<N) {
sum[i] = 0;
if(__builtin_popcount(i) <= 1) continue;
int j = i & -i;
int k = i & ~j;
sum[i] = sum[k];
rep(l, N) if((k >> l) & 1) {
sum[i] += as[l][__builtin_ffs(j)-1];
}
}
}
void solve() {
build_sum();
rep(i, 1<<N) {
dp[i] = sum[i];
if(__builtin_popcount(i) <= 2) continue;
int j = i;
do {
int k = i & ~j;
if(j != 0 || k != 0) {
dp[i] = max(dp[i], dp[j] + dp[k]);
j = (j - 1) & i;
}
} while(j != i);
}
cout << max(0LL, dp[(1<<N)-1]) << "\n";
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
solver::init();
solver::solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, M, Q;
cin >> N >> M >> Q;
vector<vector<int>> cnt_vec(N + 1, vector<int>(N + 1, 0));
int L, R;
for (int i = 0; i < M; ++i) {
cin >> L >> R;
cnt_vec.at(L).at(R) += 1;
}
vector<vector<int>> cumsum(N + 1, vector<int>(N + 1, 0));
for (int i = N; i > 0; --i) {
for (int j = 1; j <= N; ++j) {
cumsum.at(i).at(j) = cnt_vec.at(i).at(j);
cumsum.at(i).at(j) += cumsum.at(i).at(j - 1);
if (i < N) {
cumsum.at(i).at(j) += cumsum.at(i + 1).at(j);
cumsum.at(i).at(j) -= cumsum.at(i + 1).at(j - 1);
}
}
}
int p, q;
for (int i = 0; i < Q; ++i) {
cin >> p >> q;
cout << cumsum.at(p).at(q) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update>
#define ld long double
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define all(a) a.begin(),a.end()
#define sz(a) (ll)(a.size())
const int M = 1e6+6;
ll seg[4*M],lazy[4*M],ct[4*M];
ll ans[100];
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int n;
cin>>n;
string s;
cin>>s;
s = "$"+s;
int q;
cin>>q;
while(q--)
{
int k;
cin>>k;
ll ans = 0;
ll m = 0;
ll d = 0;
ll cur = 0;
for(int i=1;i<=n;i++)
{
if(i>k)
{
// delete i-k
if(s[i-k] == 'D')
{
cur -= m;
d--;
}
if(s[i-k] == 'M')
{
m--;
}
}
if(s[i] == 'D')
d++;
if(s[i] == 'M')
{
m++;
cur += d;
}
if(s[i] == 'C')
ans += cur;
}
cout<<ans<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<vector<long long> > vvll;
typedef vector<pair<int, int> > vpii;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;
#define INF 1000000000
#define MOD 1000000007
#define EPSILON 0.00001
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define p_q priority_queue
#define FOR(i, a, b) for (ll i=(a); i<=(b); i++)
#define F0R(i, a) for (int i=0; i<(a); i++)
#define RFOR(i, a, b) for (int i=(a); i >= b; i--)
#define MN 500005
#define MX 1048600
int n;
ll a[MN];
ll ps[MN];
ll lst[MX]; //last time we saw 0
ll cnt[MX];
pll dp[MX]; //cnt for k, cnt for 0
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
FOR(i, 1, n){
cin >> a[i];
ps[i] = ps[i-1] ^ a[i];
}
ll ov = ps[n];
//cout << ov << "\n";
if(ov != 0){
ll isn = 0;
ll isz = 1;
FOR(i, 1, n-1){
if(ps[i] == 0){
isz = (isn+isz)%MOD;
} else if(ps[i] == ov){
isn = (isn+isz)%MOD;
}
}
cout << isz << "\n";
} else{
int tm = 0;
dp[0].f = 1;
FOR(i, 1, MX-1){
dp[i].s = 1;
}
FOR(i, 1, n-1){
//cout << ps[i] << " ";
if(ps[i] == 0){
tm++;
dp[0].f = (dp[0].f*2)%MOD;
} else{
int j = ps[i];
int dif = tm-lst[j];
dp[j].s = (dp[j].s + dp[j].f*dif) % MOD;
dp[j].f = (dp[j].f + dp[j].s) % MOD;
lst[j] = tm;
}
}
//cout << "\n";
ll sm = 0;
F0R(i, MX){
/*if(dp[i].f != 0){
cout << i << " adds " << dp[i].f << "\n";
}*/
sm += dp[i].f;
sm %= MOD;
}
//cout << "\n";
cout << sm << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
const int MAXN = 2e5 + 21, LG = 61;
int n, m;
long long k;
long long a[MAXN], d[MAXN], p[MAXN][LG];
vector <long long> res;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i];
res.pb(a[1]);
cin >> m >> k;
for (int i = 1; i < n; i++) {
d[i] = a[i + 1] - a[i];
p[i][0] = i;
}
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
swap(p[x - 1][0], p[x][0]);
}
for (int i = 1; i < LG; i++)
for (int j = 1; j < n; j++) {
p[j][i] = p[p[j][i - 1]][i - 1];
}
for (int i = 1; i < n; i++) {
int cur = i;
for (int i = LG - 1; ~i; i--)
if (k & (1LL << i))
cur = p[cur][i];
res.pb(res.back() + d[cur]);
}
for (auto y: res)
cout << y << '\n';
return 0;
}
| 0 |
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;
double pi = 3.1415926535897932384646433;
typedef long long ll;
typedef pair<ll, ll>pii;
ll ccw(pii a, pii b, pii c)
{
return (b.first - a.first)*(c.second - b.second) - (b.second - a.second)*(c.first - b.first);
}
double dist(pii a, pii b)
{
return sqrt(double((b.first - a.first)*(b.first - a.first) + (b.second - a.second)*(b.second - a.second)));
}
double dot(pii a, pii b)
{
return double(a.first*b.first + a.second*b.second);
}
double ans[111];
int main()
{
fill(ans, ans + 111, 0);
int num;
scanf("%d", &num);
vector<pii>v;
map<pii, int>ma;
for (int i = 0; i < num; i++)
{
ll a, b;
scanf("%lld%lld", &a, &b);
v.push_back(make_pair(a, b));
ma[make_pair(a, b)] = i;
}
sort(v.begin(), v.end());
vector<pii>v1, v2;
for (int i = 0; i < num; i++)
{
for (;;)
{
if (v1.size() <= 1)break;
pii a = v1[v1.size() - 2], b = v1[v1.size() - 1];
if (ccw(a, b, v[i])<0)v1.pop_back();
else break;
}
v1.push_back(v[i]);
}
for (int i = 0; i < num; i++)
{
for (;;)
{
if (v2.size() <= 1)break;
pii a = v2[v2.size() - 2], b = v2[v2.size() - 1];
if (ccw(a, b, v[i])>0)v2.pop_back();
else break;
}
v2.push_back(v[i]);
}
for (int i = int(v2.size()) - 2; i >= 1; i--)v1.push_back(v2[i]);
for (int i = 0; i < v1.size(); i++)
{
pii s = v1[(i + v1.size() - 1) % v1.size()];
pii t = v1[i];
pii u = v1[(i + 1) % v1.size()];
//printf("%lld %lld %lld %lld %lld %lld\n", s.first, s.second, t.first, t.second, u.first, u.second);
double x = acos(dot(make_pair(u.first - t.first, u.second - t.second), make_pair(s.first - t.first, s.second - t.second)) / dist(s, t) / dist(t, u));
ans[ma[v1[i]]] = (pi - x) / (2 * pi);
}
for (int i = 0; i < num; i++)printf("%.6lf\n", ans[i]);
}
| #include <bits/stdc++.h>
using namespace std;
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(int i = (int)(a); i < (int)(b); i++)
#define rep(...) _overload(__VA_ARGS__, repi, _rep)(__VA_ARGS__)
double res, PI = acos(-1);
int n;
main(){
cin >> n;
int x[n], y[n];
rep(i, n) cin>>x[i]>>y[i];
rep(i, n){
vector<double> d;
rep(j, n) if(i != j) d.push_back(atan2(y[j] - y[i], x[j] - x[i]));
sort(begin(d),end(d));
res = d[0] - d[d.size() - 1] + PI;
rep(j, 1, d.size()) res=max(res,d[j] - d[j - 1] - PI);
cout<<max(0.0, res / 2.0 / PI)<<'\n';
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cout << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
const long long mod = 1e9+7; // CHECK
long long power(long long a, long long b, long long m = mod) {
if(b < 0) {
return power(power(a, -b), mod-2);
}
long long x = 1;
while(b) {
if(b & 1) {
x = 1ll * x * a % m;
}
a = 1ll * a * a % m;
b /= 2;
}
return x;
}
#define ll long long
const int INT_INF = 1e9+9;
const ll LL_INF = 2e18;
const int N = 3e5+9;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int n; cin >> n;
int latest_start = 0, earliest_finish = 0;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
if (a[latest_start].first < a[i].first) {
latest_start = i;
}
if (a[earliest_finish].second > a[i].second) {
earliest_finish = i;
}
}
int ans = 0;
// both in same
{
int longest = -INT_INF;
for (int i = 0; i < n; i++) {
if (i == earliest_finish || i == latest_start) continue;
longest = max(longest, a[i].second - a[i].first + 1);
}
ans = max(ans, longest + max(a[earliest_finish].second - a[latest_start].first + 1, 0));
}
// earliest_finish in left
{
vector<pair<int, int>> b;
for (int i = 0; i < n; i++) {
if (i == earliest_finish || i == latest_start) continue;
b.push_back({max(0, a[earliest_finish].second - a[i].first + 1),
-max(0, a[i].second - a[latest_start].first + 1)});
}
sort(b.begin(), b.end());
int mn_right = a[latest_start].second - a[latest_start].first + 1;
for (int i = 0; i < n-2; i++) {
ans = max(ans, b[i].first + mn_right);
mn_right = min(mn_right, -b[i].second);
}
ans = max(ans, mn_right + a[earliest_finish].second - a[earliest_finish].first + 1);
}
cout << ans << '\n';
return 0;
}
| #include<bits/stdc++.h>
#define ll long long
#define dl double
#define mp make_pair
#define pb push_back
using namespace std;
//***********************************************************************
// hash struct for unordered_map
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const
{
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int MAXNUM = 5e3+5;
vector <int>vis(MAXNUM);
vector<int> pr;
void sieve() {
pr.push_back(2);
for(ll i=3;i<MAXNUM;i+=2) if(!vis[i]) {
pr.push_back(i);
for(ll j=i*i;j<MAXNUM;j+=2*i) vis[j]=true;
}
}
//************************************************************************
ll cnt[1<<16];
ll dp[1<<16];
// ll finddpvalue(ll mask,ll pos)
// {
// if(pos==-1)
// {
// return cnt[mask];
// }
// if(dp[mask][pos]!=-1)
// {
// return dp[mask][pos];
// }
// ll ans=0;
// ans+=finddpvalue(mask,pos-1);
// if(mask&(1<<pos))
// ans+=finddpvalue(mask^(1<<pos),pos-1);
// return dp[mask][pos]=ans;
// }
ll finddpvalue2(int mask)
{
if(mask==0)
return 0;
if(dp[mask]!=-1)
return dp[mask];
ll ans=cnt[mask];
for(int i = (mask-1)&mask; i > 0; i = (i-1) & mask)
{
int group=mask^i;
//cout << "mask : " << mask << " i : " << i << " grp :" << group << endl;
ans=max(ans,cnt[group]+finddpvalue2(i));
}
return dp[mask]=ans;
}
void solve()
{
ll n;
cin >> n;
vector<vector<ll>> v(n,vector<ll>(n));
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cin >> v[i][j];
}
}
memset(cnt,0,sizeof cnt);
for(ll mask=0;mask<(1<<n);mask++)
{
for(ll i=0;i<n;i++)
{
if(mask&(1<<i))
{
for(ll j=i+1;j<n;j++)
{
if(mask&(1<<j))
cnt[mask]+=v[i][j];
}
}
}
}
memset(dp,-1,sizeof dp);
//cout << "c0" << endl;
ll ans=finddpvalue2((1<<n)-1);
//cout << "c0" << endl;
cout << ans << endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
//cin >> t;
t=1;
while(t--)
{
solve();
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int cntD(ll i){
int cnt = 0;
if( i == 0) return 1;
while(i>0){
i /= 10;
++cnt;
}
return cnt;
}
ll f (ll i, ll j){
return max(cntD(i), cntD(j));
}
int main(){
ll n;
cin >> n;
ll d = cntD(n);
for(ll a = 1; a*a<=n; ++a){
if(n%a != 0) continue;
ll b = n/a;
d = min(d, f(a,b));
}
cout << d;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = (n - 1); i >= 0; --i)
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define mt(p, q, r) make_tuple(p, q, r)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<ll> vll;
typedef vector<ld> vd;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<str> vs;
typedef vector<vector<ll>> vvll;
typedef vector<vector<ld>> vvd;
typedef vector<vector<bool>> vvb;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
typedef vector<pair<ll, ll>> vpll;
typedef vector<tuple<ll, ll, ll>> vtlll;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
template <typename T>
void fin(T a)
{
cout << a << endl;
exit(0);
}
bool IsPrime(ll num)
{
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
ld sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
return false;
}
return true;
}
//実行部
void Main()
{
str s; ll w; cin >> s >> w;
rep(i, s.size())
{
if(i % w == 0) cout << s[i];
}
cout << endl;
}
//前処理
int main()
{
ifstream in("text.txt");
cin.rdbuf(in.rdbuf());
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20); //高精度少数表示
Main();
return 0;
}
/*
//test時
g++ test.cpp -o test;./test
*/
| 0 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mk make_pair
#define MAX 1000001
ll prime[MAX];
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
#define mod 1000000007
#define gcd __gcd
// ll rec(vector<vector<ll> >& dp,vector<ll>& arr,int n,int i,int k,int w)
// {
// ll ans=0;
// if(i>=n)
// return 0;
// if(dp[i][k]!=-1)
// return dp[i][k];
// if(k!=0)
// ans=max(rec(dp,arr,n,i+1,w,w),arr[i]+rec(dp,arr,n,i+1,k-1,w));
// else
// ans=max(rec(dp,arr,n,i+1,k,w),rec(dp,arr,n,i+1,w,w));
// return dp[i][k]=ans;
// }
//ll t[400008];
// void build(vector<ll>& a, int v, int tl, int tr) {
// if (tl == tr) {
// t[v] = a[tl];
// } else {
// int tm = (tl + tr) / 2;
// build(a, v*2, tl, tm);
// build(a, v*2+1, tm+1, tr);
// t[v] = max(t[v*2] ,t[v*2+1]);
// }
// }
// ll maxi(int v, int tl, int tr, int l, int r) {
// if (l > r)
// return 0;
// if (l == tl && r == tr) {
// return t[v];
// }
// int tm = (tl + tr) / 2;
// return max(maxi(v*2, tl, tm, l, min(r, tm)) ,maxi(v*2+1, tm+1, tr, max(l, tm+1), r));
// }
// void update(int v, int tl, int tr, int pos, ll new_val) {
// if (tl == tr) {
// t[v] = new_val;
// } else {
// int tm = (tl + tr) / 2;
// if (pos <= tm)
// update(v*2, tl, tm, pos, new_val);
// else
// update(v*2+1, tm+1, tr, pos, new_val);
// t[v] = max(t[v*2] ,t[v*2+1]);
// }
// }
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const{
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
int temp[1000002]={0};
void sieve()
{
temp[1]=1;
for(int i=2;i<1000002;i++)
{
if(temp[i]==0)
{ temp[i]=i;
for(int j=i*2;j<1000002;j+=i)
{
if(temp[j]==0)
temp[j]=i;
}
}
}
}
int dfs(int i,vector<vector<int> > &g,vector<int>& p,vector<int>& c)
{
int sub=1;
for(auto x:g[i])
{
if(p[i]!=x)
{
p[x]=i;
sub+=dfs(x,g,p,c);
}
}
return c[i]=sub;
}
int main() {
int n;
cin>>n;
int a[n],fa[n+1]={0};
int b[n],fb[n+1]={0};
for(int i=0;i<n;i++)
{
cin>>a[i];
fa[a[i]]++;
}
for(int i=0;i<n;i++)
{
cin>>b[i];
fb[b[i]]++;
}
int flag=0;
for(int i=1;i<=n;i++)
{
if(fa[i]+fb[i]>n)
{
flag=1;
break;
}
}
if(flag)
{
cout<<"No"<<"\n";
return 0;
}
cout<<"Yes"<<"\n";
reverse(b,b+n);
int i=0;
int j=0;
while(i<n)
{
if(a[i]!=b[i])
{ i++;
continue;}
swap(b[i],b[j]);
j++;
}
i=n-1;
j=n-1;
while(i>=0)
{
if(a[i]!=b[i])
{ i--;
continue;}
swap(b[i],b[j]);
j--;
}
for(int i=0;i<n;i++)
cout<<b[i]<<" ";
cout<<"\n";
return 0;
}
/*
1
4
1 2
2 3
3 4
*/
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int a[n],b[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<n;i++)
{
cin>>b[n-i-1];
}
int val=-1;
for(int i=0;i<n;i++)
{
if(a[i]==b[i])
{
val=a[i];
break;
}
}
if(val==-1)
{
cout<<"Yes"<<endl;
for(int i=0;i<n;i++)
{
cout<<b[i]<<' ';
}
cout<<endl;
}
else
{
vector<int> t_change,available;
for(int i=0;i<n;i++)
{
if(a[i]!=val && b[i]!=val)
{
available.push_back(i);
}
if(a[i]==val && b[i]==val)
{
t_change.push_back(i);
}
}
if(t_change.size()>available.size())
{
cout<<"No"<<endl;
}
else
{
for(auto i:t_change)
{
int ind=*(available.end()-1);
swap(b[i],b[ind]);
available.pop_back();
}
cout<<"Yes"<<endl;
for(int i=0;i<n;i++)
{
cout<<b[i]<<' ';
}
cout<<endl;
}
}
return 0;
} | 1 |
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define INF 1000000000000000000
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<ll> A(N);
rep(i, N) { cin >> A[i]; }
ll sum = 0;
vector<bool> B(N, false);
if (A[0] != 0) {
cout << -1 << endl;
return 0;
}
rep(i, N - 1) {
if (A[i + 1] > A[i] + 1) {
cout << -1 << endl;
return 0;
}
if (A[i + 1] - A[i] == 1)
B[i + 1] = true, sum++;
}
rep(i, N) {
if (!B[i])
sum += A[i];
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int A[100050];
int n,l,q;
int dp[100050][20];
int main(){
//freopen("input.in","r",stdin);
cin >> n;
for(int i=1; i<=n; ++i) cin >> A[i];
cin >> l;
for(int i=1; i<=n; ++i) dp[i][0] = upper_bound(A+1,A+n+1,A[i]+l)-A-1;
for(int k=1; k<=18; ++k){
for(int i=1; i<=n; ++i){
dp[i][k] = dp[dp[i][k-1]][k-1];
}
}
// for(int k=0; k<=3; ++k){ for(int i=1; i<=n; ++i) printf("%d ", dp[i][k]); printf("\n"); }
cin >> q;
while(q--){
int a, b; cin >> a >> b;
if(a > b) swap(a,b);
int ans = 0;
while(a < b){
int s=0,e=19,m;
for(int k=0; k<=18; ++k) if(dp[a][k] < b) s=k;
ans += (1<<s);
a = dp[a][s];
}
cout << ans << "\n";
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<LL,LL> P;
const LL mod=998244353;
const LL LINF=1LL<<60;
const int INF=1<<30;
vector<LL> fact;
vector<LL> inver(3000001);
LL combi(int n,int r){
if(n<r||n<0||r<0) return 0;
return fact[n]%mod*inver[n-r]%mod*inver[r]%mod;
}
LL fpow(LL a, LL n){
LL x = 1;
while(n > 0){
if(n&1){
x=x*a%mod;
}
a=a*a%mod;
n >>= 1;
}
return x;
}
void set_combi(){
LL s=1;
fact.push_back(1);
for(int i=1;i<=3000000;i++){
s*=i;
s%=mod;
fact.push_back(s);
}
inver[3000000]=fpow(fact[3000000],mod-2);
for(int i=2999999;i>=0;i--){
inver[i]=inver[i+1]*(i+1)%mod;
}
}
LL hcombi(int n,int r){
return combi(n+r-1,r);
}
int main(){
set_combi();
LL n,m;cin >> n >> m;
LL ans = 0;
for (int i = m; i >= 0; i-=2) {
ans = (ans + hcombi(n,m+(m-i)/2) * combi(n,i))%mod;
}
for (int i = 2*m+1; i <= 3*m; i++) {
ans = (ans - (n * hcombi(n-1,3*m-i))%mod + mod)%mod;
}
cout << ans << endl;
return 0;
}
| #include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
LL f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
if(x<0){putchar('-');x=-x;}
if(!x){putchar('0');return;}
int top=0;
while(x)stack[++top]=x%10,x/=10;
while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int mod=998244353;
const int MAXN=3000005;
int pre[MAXN],inv[MAXN];
int C(int n,int m)
{
if(n<m)return 0;
return 1LL*pre[n]*inv[m]%mod*inv[n-m]%mod;
}
int n,m;
void ad(int &x,int y){x+=y;if(x>=mod)x-=mod;}
void dl(int &x,int y){x-=y;if(x<0)x+=mod;}
int pow_mod(int a,int b)
{
int ret=1;
while(b)
{
if(b&1)ret=1LL*ret*a%mod;
a=1LL*a*a%mod;b>>=1;
}
return ret;
}
int main()
{
pre[0]=1;for(int i=1;i<MAXN;i++)pre[i]=1LL*pre[i-1]*i%mod;
inv[MAXN-1]=pow_mod(pre[MAXN-1],mod-2);
for(int i=MAXN-2;i>=0;i--)inv[i]=1LL*inv[i+1]*(i+1)%mod;
n=read();m=read();
int ans=0;
for(int i=0;i<=m;i++)
if(!((3*m-i)&1))
ad(ans,1LL*C(n,i)*C(((3*m-i)>>1)+n-1,n-1)%mod);
// dl(ans,1LL*n*C(m-2+n-1,n-1)%mod);
dl(ans,1LL*n*C(m-1+n-1,n-1)%mod);
pr2(ans);
return 0;
}
| 1 |
//終局から考える。
//S[i] = '1'なるiについて、A[i]が{A[j], i+1≦j≦N-1, S[j] = '0'}と独立ならx≠0.
//全て従属とする。iが大きい方から考えると、最終的にx=0(従属)にできる。
//独立性の判定:
//・各数を2進数ベクトルと考えて {A[j], i+1≦j≦N-1, S[j] = '0'}について掃き出し法をおこない、
// 表現できるベクトル集合が同一のより単純な表現に直す
//・その表現では'1'の立つ最上位ビットの場所がdistinctだから、A[i]を作れるかを貪欲に判定できる
//計算量はO(TN^3). 厳しい？ -> 定数倍が軽いので大丈夫そう.
//0ベクトルを取り除かない上に、S[i] = '1'なるiについてもA[i]を追加してしまったバージョン
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for(i = 0; i < n; i++)
#define int long long
using namespace std;
void sweep(vector<int> &vs) {
int n = vs.size();
int row = 0;
for (int i = 59; i >= 0; i--) {
int pipot = -1;
for (int j = row; j < n; j++) {
if ((vs[j] >> i) & 1) {
pipot = j;
break;
}
}
if (pipot == -1) continue;
swap(vs[row], vs[pipot]);
for (int j = row + 1; j < n; j++) {
if ((vs[j] >> i) & 1) {
vs[j] ^= vs[row];
}
}
row++;
}
}
int solve(vector<int> a, string s) {
int n = a.size();
vector<int> vs;
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '0') {
vs.push_back(a[i]);
}
else {
sweep(vs);
int val = a[i];
for (int j = 0; j < vs.size(); j++) {
if ((val ^ vs[j]) < val) {
val ^= vs[j];
}
}
if (val != 0) return 1;
vs.push_back(a[i]);
}
}
return 0;
}
signed main() {
int T;
cin >> T;
while (T--) {
int i, n; cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
string s; cin >> s;
cout << solve(a, s) << endl;
}
return 0;
} | #include <iostream>
#include<bits/stdc++.h>
#define base 950527
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
vector<P> res;
ll lh,ns,nt,LH,tmp=1,n,s[200005],t[200005],K[200005],S[200005],T[200005];
int main(void){
cin>>n;
for(int i=0;i<n;i++){
cin>>S[i];
}
for(int i=0;i<n;i++){
cin>>T[i];
}
for(int i=0;i<n;i++){
K[i]=S[i]^T[0];
}
for(int i=0;i<n;i++){
s[i]=S[i]^S[(i+1)%n];
t[i]=T[i]^T[(i+1)%n];
//cout<<s[i]<<endl;
}
//cin>>s>>t;
ns=n;
nt=n;
for(int i=0;i<nt;i++){
lh=lh*base+s[i];
LH=LH*base+t[i];
tmp*=base;
}
if(lh==LH)res.push_back({0,K[0]});
for(int i=0;i<ns-1;i++){
lh=lh*base-tmp*s[i];
lh+=s[i];
//cout<<LH<<" "<<lh<<" "<<i<<endl;
if(LH==lh)res.push_back({i+1,K[i+1]});
}
sort(res.begin(),res.end());
for(auto x:res){
cout<<x.first<<" "<<x.second<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(i, 0, n) cin >> v[i];
ll ans = 0;
rep(l, 0, k + 1) {
rep(r, 0, k - l + 1) {
if (l + r > n)
continue;
int d = k - l - r;
ll now = 0;
vector<int> s;
rep(i, 0, l) {
now += v[i];
s.push_back(v[i]);
}
rep(i, n - r, n) {
now += v[i];
s.push_back(v[i]);
}
sort(s.begin(), s.end());
rep(i, 0, d) {
if (i >= s.size() || s[i] > 0)
break;
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N,x;
cin>>N>>x;
vector<int> A(N);
for(int &i:A)cin>>i;
sort(A.begin(),A.end());
int ans=0;
for(int i=0;i<N;i++){
x-=A[i];
if(x<0)break;
ans++;
}
if(ans==N && x!=0)cout<<N-1<<endl;
else cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template<typename T, typename E> struct LazySegmentTree {
using F = function<T(T, T)>;
using G = function<T(T, E)>;
using H = function<E(E, E)>;
using P = function<E(E, int)>;
int n;
T ti;
E ei;
F f;
G g;
H h;
P p;
vector<T> data;
vector<E> lazy;
LazySegmentTree(int n_, F f, G g, H h, T ti = INT_MAX, E ei = INT_MAX,
P p = [](E a, int b) { return a; })
: f(f), g(g), h(h), ti(ti), ei(ei), p(p) {
init(n_);
}
void init(int n_) {
n = 1;
while (n < n_) n *= 2;
data.assign(n * 2 - 1, ti);
lazy.assign(n * 2 - 1, ei);
}
void build(vector<T> v) {
for (int i = 0; i < v.size(); ++i) data[i + n - 1] = v[i];
for (int i = n - 2; i >= 0; --i) {
data[i] = f(data[i * 2 + 1], data[i * 2 + 2]);
}
}
inline void eval(int len, int k) {
if (lazy[k] == ei) return;
if (k * 2 + 1 < n * 2 - 1) {
lazy[k * 2 + 1] = h(lazy[k * 2 + 1], lazy[k]);
lazy[k * 2 + 2] = h(lazy[k * 2 + 2], lazy[k]);
}
data[k] = g(data[k], p(lazy[k], len));
lazy[k] = ei;
}
T update(int a, int b, E x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(r - l, k);
if (b <= l || r <= a) return data[k];
if (a <= l && r <= b) {
lazy[k] = h(lazy[k], x);
return g(data[k], p(lazy[k], r - l));
}
T vl = update(a, b, x, k * 2 + 1, l, (l + r) / 2);
T vr = update(a, b, x, k * 2 + 2, (l + r) / 2, r);
return data[k] = f(vl, vr);
}
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(r - l, k);
if (b <= l || r <= a) return ti;
if (a <= l && r <= b) return data[k];
T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q; cin >> n >> q;
const int INF = INT_MAX;
LazySegmentTree<int, int>::F f = [&](int a, int b) { return min(a, b); };
LazySegmentTree<int, int>::G g = [&](int a, int b) { return (b == INF) ? a : b; };
LazySegmentTree<int, int>::H h = [&](int a, int b) { return (b == INF) ? a : b; };
LazySegmentTree<int, int>::P p = [&](int a, int b) { return (a == INF) ? a : a * b; };
LazySegmentTree<int, int> seg(n, f, g, h);
for (int i = 0; i < q; ++i) {
int com; cin >> com;
if (com) {
int i; cin >> i;
cout << seg.query(i, i + 1) << endl;
} else {
int s, t, x; cin >> s >> t >> x;
seg.update(s, t + 1, x);
}
}
return 0;
}
| #include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <iomanip>
#include <cstdlib>
using namespace std;
int main () {
int n,m,i,j,t=0;
int a,b,c,d,f,g,a11,b1,c1,d1,f1,g1;
string s="EEEESEEEESEEEESEEEESESEEEESSEEE";
n=s.size();
int a1[n+1],a2[n+1],a3[n+1],a4[n+1],a5[n+1],a6[n+1];
cin >> m;
cin >> a >> b >> c >> d >> f >> g ;
for(j=0;j<m-1;j++){
int a1[n+1],a2[n+1],a3[n+1],a4[n+1],a5[n+1],a6[n+1];
cin >> a11 >> b1 >> c1 >> d1 >> f1 >> g1;
a1[0]=a11; a2[0]=b1; a3[0]=c1; a4[0]=d1; a5[0]=f1; a6[0]=g1;
for(i=0;i<n;i++){
if(s[i]=='S'){
a1[i+1]=a5[i]; a2[i+1]=a1[i]; a3[i+1]=a3[i]; a4[i+1]=a4[i]; a5[i+1]=a6[i]; a6[i+1]=a2[i];
}
else if(s[i]=='N'){
a1[i+1]=a2[i]; a2[i+1]=a6[i]; a3[i+1]=a3[i]; a4[i+1]=a4[i]; a5[i+1]=a1[i]; a6[i+1]=a5[i];
}
else if(s[i]=='W'){
a1[i+1]=a3[i]; a2[i+1]=a2[i]; a3[i+1]=a6[i]; a4[i+1]=a1[i]; a5[i+1]=a5[i]; a6[i+1]=a4[i];
}
else if(s[i]=='E'){
a1[i+1]=a4[i]; a2[i+1]=a2[i]; a3[i+1]=a1[i]; a4[i+1]=a6[i]; a5[i+1]=a5[i]; a6[i+1]=a3[i];
}
if((a1[i+1]==a)&&(a2[i+1]==b)&&(a3[i+1]==c)&&(a4[i+1]==d)&&(a5[i+1]==f)&&(a6[i+1]==g)){
t=1; break;
}
}
}
if(t==1) cout << "No" << endl;
else cout << "Yes" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n; cin >> n;
vector<int> a(n + 2, 0);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int sum = 0;
for (int i = 1; i <= n + 1; i++) {
sum +=abs(a[i] - a[i - 1]);
}
for (int i = 1; i <= n; i++) {
int tmp = sum;
tmp -= abs(a[i] - a[i - 1]);
tmp -= abs(a[i + 1] - a[i]);
tmp += abs(a[i + 1] - a[i - 1]);
cout << tmp << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, s, n) for (ll i = s; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << endl
#define COUTF(x) cout << setprecision(15) << (x) << endl
#define ENDL cout << endl
#define DF(x) x.erase(x.begin()) // 先頭文字削除
#define ALL(x) x.begin(), x.end()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#define init() \
cin.tie(0); \
ios::sync_with_stdio(false)
#define debug(x) cerr << "[debug] " << #x << ": " << x << endl;
#define debugV(v) \
cerr << "[debugV] " << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl;
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr ld PI = 3.141592653589793238462643383279;
ll get_digit(ll x) {
return to_string(x).size();
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
vll divisor(ll n) {
vll ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
SORT(ret);
return (ret);
}
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;
}
signed main() {
init();
ll N;
cin >> N;
vll A(N);
ll sum = 0;
rep(i, N) {
ll a;
cin >> a;
A[i] = a;
if (i == 0) {
sum += abs(a);
} else {
sum += abs(a - A[i - 1]);
}
}
sum += abs(A[N - 1]);
rep(i, N) {
if (i == 0) {
ll ans = sum - abs(A[0]) - abs(A[0] - A[1]) + abs(A[1]);
COUT(ans);
continue;
}
if (i == N - 1) {
ll ans = sum - abs(A[N - 1]) - abs(A[N - 2] - A[N - 1]) + abs(A[N - 2]);
COUT(ans);
continue;
}
ll a = abs(A[i - 1] - A[i]);
ll b = abs(A[i] - A[i + 1]);
ll c = abs(A[i - 1] - A[i + 1]);
ll ans = sum - a - b + c;
COUT(ans);
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define reg register
#define ll long long
#define maxn 100005
inline ll read()
{
ll x=0,w=0;char ch=getchar();
while(!isdigit(ch))w|=ch=='-',ch=getchar();
while(isdigit(ch))x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
return w?-x:x;
}
int n,m;ll k;
int b[maxn],to[70][maxn],c[maxn];
double a[maxn],d[maxn];
int main()
{
n=read();reg int i,j;
for(i=1;i<=n;++i)a[i]=read();
for(i=2;i<=n;++i)d[i]=a[i]-a[i-1];
m=read(),k=read();
for(i=1;i<=m;++i)b[i]=read();
for(i=1;i<=n;++i)to[0][i]=i,c[i]=i;
for(i=1;i<=m;++i)swap(to[0][b[i]],to[0][b[i]+1]);
for(j=1;j<=62;++j)for(i=2;i<=n;++i)
to[j][i]=to[j-1][to[j-1][i]];
for(j=62;j>=0;--j)if(k>=(1ll<<j))
{
for(i=2;i<=n;++i)c[i]=to[j][c[i]];
k^=(1ll<<j);
}
for(i=2;i<=n;++i)a[i]=d[c[i]]+a[i-1];
for(i=1;i<=n;++i)printf("%.9lf\n",a[i]);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define all(v) v.begin(),v.end()
#define inf (int)(3e18)
#define P pair<int,int>
#define mod (int)(1e9+7)
#define mod2 998244353
template<class T> inline void chmin(T &a, T b) {
a = min(a, b);
}
template<class T> inline void chmax(T &a, T b) {
a = max(a, b);
}
int mod_pow(int x, int y, int m = mod) {
int res = 1;
x %= m;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int perm[1000005];
void init_perm(){
perm[0]=1;
REP(i,1000005)perm[i]=perm[i-1]*i%mod;
}
int nCk(int x,int y){
if(x<y)return 0;
return perm[x]*mod_pow(perm[x-y],mod-2)%mod*mod_pow(perm[y],mod-2)%mod;
}
int N,A,B,C,D;
int dp[1005][1005];
signed main(){
init_perm();
cin>>N>>A>>B>>C>>D;
dp[0][1]=1;
rep(i,N){
REP(j,N){
dp[i][j]%=mod;
dp[i][j+1]+=dp[i][j];
}
for(int j=A;j<=B;j++){
int ans=1,rem=N-i;
REP(k,D+1){
if(i+j*k>N)break;
ans*=nCk(rem,j);
ans%=mod;
rem-=j;
if(k>=C){
dp[i+j*k][j+1]+=dp[i][j]*ans%mod*mod_pow(perm[k],mod-2)%mod;
dp[i+j*k][j+1]%=mod;
}
}
}
}
int ans=0;
rep(i,N+2){
//cout<<dp[N][i]<<endl;
ans+=dp[N][i]%mod;
}
cout<<ans%mod<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
ll H, W, N;
cin >> H >> W >> N;
cout << N / max(H, W) + !!(N % max(H, W)) << endl;
return 0;
}
| #include <stdio.h>
int main() {
int h,w,n;
scanf("%d", &h);
scanf("%d", &w);
scanf("%d", &n);
int ctr = 0;
int total = 0;
while (n > total){
if(w >= h){
total += w;
ctr++;
}else if(h > w){
total += h;
ctr++;
}
}
printf("%d\n",ctr);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int n,a[200100],b[200100],cnt[200100],res[200100],f[400100],g[200100],nxt[200100];
void kmp(){
for(int i=2,j=0;i<=n;i++){
while(j&&g[j+1]!=g[i])j=nxt[j];
if(g[j+1]==g[i])j++;
nxt[i]=j;
}
for(int i=1,j=0;i<2*n;i++){
while(j&&g[j+1]!=f[i])j=nxt[j];
if(g[j+1]==f[i])j++;
if(j==n)cnt[i-n+1]++,j=nxt[j];
}
}
bool ok[200100];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",&a[i]),res[i]=0;
for(int i=1;i<=n;i++)scanf("%d",&b[i]);
for(int i=0;i<30;i++){
for(int j=1;j<=n;j++)f[j]=f[j+n]=(a[j]&(1<<i))>0,g[j]=(b[j]&(1<<i))>0,cnt[j]=ok[j]=0;
kmp();
// for(int j=1;j<=2*n;j++)printf("%d",f[j]);puts("");
// for(int j=1;j<=n;j++)printf("%d",g[j]);puts("");
// printf("%d1:",i);for(int j=1;j<=n;j++)printf("%d ",cnt[j]);puts("");
for(int j=1;j<=n;j++){
g[j]^=1;
if(res[j]!=-1&&cnt[j])ok[j]=true;
cnt[j]=0;
}
kmp();
// printf("%d2:",i);for(int j=1;j<=n;j++)printf("%d ",cnt[j]);puts("");
for(int j=1;j<=n;j++)if(res[j]!=-1&&cnt[j])res[j]|=(1<<i),ok[j]=true;
for(int j=1;j<=n;j++)if(!ok[j])res[j]=-1;
}
for(int i=1;i<=n;i++)if(res[i]!=-1)printf("%d %d\n",i-1,res[i]);
return 0;
} | #include <iostream>
#include <utility>
using namespace std;
int main(void) {
int n,a[100];
cin >> n;
for(int i = 0;i < n;i++) cin >> a[i];
bool flag = true;
int cnt = 0;
while(flag) {
flag = false;
for(int j = n-1;j > 0;j--) {
if(a[j]<a[j-1]) {
swap(a[j],a[j-1]);
flag = true;
cnt++;
}
}
}
for(int i = 0;i < n-1;i++) cout << a[i] << " ";
cout << a[n-1] << endl << cnt << endl;
}
| 0 |
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
ll mod=1e9+7;
ll fac[210];
void modfac(ll n){
fac[0]=1;
for(ll i=1;i<n;i++){
fac[i]=(fac[i-1]*i)%mod;
}
}
ll modinv(ll a){
ll b=mod,u=1,v=0;
while(b){
ll t=a/b;
a-=t*b; swap(a,b);
u-=t*v; swap(u,v);
}
u%=mod;
if(u<0) u+=mod;
return u;
}
ll dp[210][100010];
int main(){
ll n,x;
cin >> n >> x;
ll a[n];
for(ll i=0;i<n;i++) cin >> a[i];
sort(a,a+n);
reverse(a,a+n);
ll inv[n+1];
for(ll i=1;i<=n;i++) inv[i]=modinv(i);
for(ll i=0;i<=x;i++) dp[n][i]=i;
for(ll i=n-1;i>=0;i--){
for(ll j=0;j<=x;j++){
ll p=n-i;
dp[i][j]=inv[p]*(dp[i+1][j%a[i]]+(p-1)*dp[i+1][j]%mod)%mod;
}
}
modfac(210);
cout << dp[0][x]*fac[n]%mod << endl;
} | #include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <numeric>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
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; }
inline bool Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "";
for (auto i = start;i != goal;i++) ans += to_string(*i)+" ";
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e17;
const ll MOD = 1000000007;
typedef pair<ll,ll> P;
const ll MAX = 200005;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll 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;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m,k;
cin >> n >> m >> k;
ll ans = 0;
COMinit();
rep(i,n){
rep(j,m-1){
ans += (j+1)*n*(m-j-1)%MOD;
ans %= MOD;
}
}
rep(i,n-1){
rep(j,m){
ans += (i+1)*m*(n-i-1)%MOD;
ans %= MOD;
}
}
PRINT(ans*COM(n*m-2,k-2)%MOD);
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
const int MAX = 700000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
/*第二引数で第一引数を割ったときの切り上げの計算*/
long long int maxtime(long long int x, long long int y) {
return(x + y - 1) / y;
}
/*最大公約数*/
long long int lcm(long long int number1, long long int number2) {
long long int m = number1;
long long int n = number2;
if (number2 > number1) {
m = number2;
n = number1;
}
long long int s = -1;
while (s != 0) {
s = m % n;
m = n;
n = s;
}
return m;
}
/*最大公倍数*/
long long int gcd(long long int number1, long long int number2) {
long long int m = number1;
long long int n = number2;
return m / lcm(m, n) * n;
}
/*逆元計算*/
long long int modinv(long long a, long long m) {
long long int b = m, u = 1, v = 0;
while (b) {
long long int t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// index が条件を満たすかどうか
vector<long long int >meguru;
bool isOK(int index, int key) {
if (meguru[index] >= key) return true;
else return false;
}
// 汎用的な二分探索のテンプレ
int binary_search(int key) {
int left = -1; //「index = 0」が条件を満たすこともあるので、初期値は -1
int right = (int)meguru.size(); // 「index = a.size()-1」が条件を満たさないこともあるので、初期値は a.size()
/* どんな二分探索でもここの書き方を変えずにできる！ */
while (right - left > 1) {
int mid = left + (right - left) / 2;
if (isOK(mid, key)) right = mid;
else left = mid;
}
/* left は条件を満たさない最大の値、right は条件を満たす最小の値になっている */
return right;
}
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() {
string s;
cin >> s;
if (s == "RSR") {
cout << "1";
}
else {
int a = 0;
for (int i = 0; i < 3; i++) {
if (s[i] == 'R') {
a++;
}
}
cout << a;
}
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
vector<int> t1,t2;
int input = 0;
for(int i = 0;i < 6;i++){
if(i < 4){
cin >> input;
t1.push_back(input);
}else{
cin >> input;
t2.push_back(input);
}
}
sort(t1.begin(), t1.end());
sort(t2.begin(), t2.end());
int result = t1[3] + t1[2] + t1[1] + t2[1];
cout << result << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define rep1(i, n) for (int i = 1; i < int(n); ++i)
#define repx(i, x, n) for (int i = int(x); i < int(n); ++i)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ALL(n) begin(n), end(n)
#define IN(a, x, b) ((a) <= (x) && (x) < (b))
#define OUT(a, x, b) ((x) < (a) || (x) < (b))
typedef long long ll;
typedef long double ld;
const ll INF = 1e18;
const ll MOD = 1000000007;
const ll MAX = 1e9 + 10;
int main()
{
ll N, A, B, thr, pre, now;
cin >> N >> A >> B;
thr = ll(B / A);
ll ans = 0;
cin >> pre;
rep1(i, N)
{
cin >> now;
if (now - pre > thr)
{
ans += B;
// cout << "+B" << endl;
}
else
{
ans += A * (now - pre);
// cout << "+" << A * (now - pre) << endl;
}
pre = now;
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <string.h>
#include <algorithm>
#include <cstring>
#include <queue>
#include <assert.h>
#include <cmath>
#include <stack>
#include <deque>
#include <set>
#include <unordered_map>
#include <complex>
#include <fstream>
#include <map>
#include <numeric>
#include <functional>
using namespace std;
const int mxn = 1e6+10;
int l[mxn];
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n; cin>>n;
for(int i=1; i<=2*n; i++) cin>>l[i];
sort(l+1, l+2*n+1);
int sum = 0;
for(int i=1; i<=2*n; i+=2) {
sum+=min(l[i], l[i+1]);
}
cout << sum <<'\n';
return 0;
}
//comparator function in sorting
//swapping arguments
//missing cases in dp
//dividing in modulo
//Beware of overflow and modulo
//Be mindful of overflow
//s is a matrix but forget
//length of ranges
//working with bit using ull | 0 |
// https://atcoder.jp/contests/aising2019/tasks/aising2019_c
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vl = vector<ll>;
#define rep(i, n) for(ll i = 0;i < n;i++)
#define all(i) i.begin(), i.end()
template<class T, class U> bool cmax(T& a, U b) { if (a<b) {a = b; return true;} else return false; }
template<class T, class U> bool cmin(T& a, U b) { if (a>b) {a = b; return true;} else return false; }
struct UnionFind {
struct Node {
ll parent;
ll size;
};
vector<Node> tree;
UnionFind(ll size) : tree(size) {
for (ll i = 0; i < size; i++) {
tree[i].parent = i;
tree[i].size = 1;
}
}
ll find(ll x) {
while (tree[x].parent != x) {
ll p = tree[x].parent;
tree[x].parent = tree[p].parent;
x = p;
}
return x;
}
void unite(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y) return;
if (tree[x].size < tree[y].size) swap(x, y);
tree[y].parent = x;
tree[x].size += tree[y].size;
}
bool same(ll x, ll y) {
return find(x) == find(y);
}
};
int main() {
cin.tie(0); ios::sync_with_stdio(false);
int h, w;
cin >> h >> w;
vector<string> s(h);
rep(i, h) cin >> s[i];
vi dx = {0, 0, 1, -1};
vi dy = {1, -1, 0, 0};
UnionFind uf(h*w);
rep(i, h) rep(j, w) rep(k, 4) {
int ni = i+dx[k];
int nj = j+dy[k];
if (0 <= ni && ni < h && 0 <= nj && nj < w && s[i][j] != s[ni][nj]) {
uf.unite(i*w + j, ni*w + nj);
}
}
vector<ll> black(h*w, 0), white(h*w, 0);
rep(i, h) rep(j, w) {
if (s[i][j] == '#') black[uf.find(i*w + j)]++;
else white[uf.find(i*w + j)]++;
}
ll ans = 0;
rep(i, h*w) {
ans += black[i] * white[i];
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
ll dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
ll counterb=0,counterw=0;
void dfs(ll x,ll y,ll H, ll W,vector<vector<bool>> &field,vector<vector<bool>> &check){
check[x][y]=1;
if(field[x][y]==1){counterb++;}
if(field[x][y]==0){counterw++;}
bool meter=(x+y+field[x][y])%2;
for(int i=0;i<4;i++){if(x+dx[i]>=0&&x+dx[i]<H&&y+dy[i]>=0&&y+dy[i]<W){
if(check[x+dx[i]][y+dy[i]]==0&&(x+y+dx[i]+dy[i]+field[x+dx[i]][y+dy[i]])%2==meter){
dfs(x+dx[i],y+dy[i],H,W,field,check);
};}
;}
}
int main(){
ll H;
cin >> H;
ll W;
cin >> W;
vector<vector<bool>> field(H, vector<bool>(W, 0));
vector<vector<bool>> check(H, vector<bool>(W, 0));
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
char k;
cin>>k;
if(k=='#'){field[i][j]=1;}
;}
;}
ll ans=0;
for(ll i=0;i<H;i++){
for(ll j=0;j<W;j++){
if(check[i][j]==0){
dfs(i,j,H,W,field,check);ans+=counterb*counterw;
counterb=0;counterw=0;
}
;}
;}
cout<<ans<<endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <unordered_map>
#include <queue>
#include <deque>
using namespace std;
using ll = long long;
void _cin(){} template <class Head, class... Tail> void _cin(Head&& head, Tail&&... tail){ cin >> head; _cin(forward<Tail>(tail)...); }
void _cout(){ cout << "\n"; } template <class Head, class... Tail> void _cout(Head&& head, Tail&&... tail){ cout << head; _cout(forward<Tail>(tail)...); }
template<typename S, typename T> ostream& operator<<(ostream &os, const pair<S, T> &p){ cout << "[" << p.first << ", " << p.second << "]"; return os; }
#define Sq(x) (x)*(x)
#define For(i, n) for(int i = 0; i < (n); i ++)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Cusum(T, xs, sxs) vector<T> sxs(xs.size()+1); For(i, (int)xs.size()) sxs[i+1] = sxs[i] + xs[i]
#define Cin(T, ...) T __VA_ARGS__; _cin(__VA_ARGS__)
#define Cins(T, n, xs) vector<T> xs(n); For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) vector<T> xs(n), ys(n); For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) vector<T> xs(n), ys(n), zs(n); For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinm(T, n, map) unordered_map<T, int> map; Rep(n){ Cin(T, x); map[x] ++; }
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) { for(const auto &e : xs) cout << e << " "; cout << "\n"; }
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
#define Return(expr) { Cout(expr); return 0; }
#define vc vector
#define Mini(a, x) a = min(a, x)
#define Maxi(a, x) a = max(a, x)
constexpr int MOD = 998244353;
ll modpow(ll n, ll p){
if(p == 0) return 1;
if(p % 2 == 1) return n * modpow(n, p-1) % MOD;
ll t = modpow(n, p/2);
return t*t % MOD;
}
constexpr int COMB_MAX = 210000;
ll fac[COMB_MAX], finv[COMB_MAX], inv[COMB_MAX];
void initComb(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < COMB_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 comb(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(void){
Cin(int, n, m, k);
initComb();
ll ans = 0;
For(i, k+1){
ll tmp = m * modpow(m-1, n-i-1) % MOD * comb(n-i-1 + i, i) % MOD;
// Cout(tmp);
ans = (ans + tmp) % MOD;
}
Cout(ans);
}
| #include<bits/stdc++.h>
#define int long long
using namespace std;
const int mod=1000000007;
signed main(){
int n,m,x1,y1;
cin>>n>>m>>x1;
int ans1=0,ans2=0;
for(int i=0;i<n-1;i++){
int x2;
cin>>x2;
ans1=(ans1+(x2-x1)*(i+1)%mod*(n-1-i)%mod)%mod;
x1=x2;
}
cin>>y1;
for(int i=0;i<m-1;i++){
int y2;
cin>>y2;
ans2=(ans2+(y2-y1)*(i+1)%mod*(m-1-i)%mod)%mod;
y1=y2;
}
cout<<ans1*ans2%mod;
} | 0 |
#include<bits/stdc++.h>
/* #define int long long */
/* #define double long double */
#define rep(i, n) for(int i = 0; i < (int)n; i++)
#define repa(i, s, n) for(int i = s; i < (int)n; i++)
#define MOD 1000000007
using namespace std;
using ll = long long;
typedef vector<int> vi;
typedef pair<int, int> P;
#define rrep(i,a,b) for(int i=a;i>=b;i--)
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; }
signed main(){
int n, r;
cin >> n >> r;
if(n >= 10){
cout << r << endl;
}else{
// r = ans - 100 * (10 - k)
cout << r + 100 * (10 - n) << endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
void abc_150a();
void abc_151a();
void abc_152a();
void abc_154a();
void abc_156a();
int main()
{
//abc_150a();
//abc_151a();
//abc_152a();
//abc_154a();
abc_156a();
}
void abc_150a()
{
int K, X;
cin >> K >> X;
if (500 * K >= X) cout << "Yes\n";
else cout << "No\n";
}
void abc_151a()
{
char C;
cin >> C;
cout << (char)((int)C + 1) << "\n";
}
void abc_152a()
{
int N, M;
cin >> N >> M;
if (N == M) cout << "Yes\n";
else cout << "No\n";
}
void abc_154a()
{
string S, T;
cin >> S >> T;
int a, b;
cin >> a >> b;
string U;
cin >> U;
if (S == U) cout << a - 1 << " " << b << "\n";
else cout << a << " " << b - 1 << "\n";
}
void abc_156a()
{
int N, R;
cin >> N >> R;
if (N >= 10) cout << R << "\n";
else cout << R + 100 * (10 - N) << "\n";
} | 1 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
const int N=1000100,P=1e9+7;
inline int read(){
int x=0,f=0,c=getchar();
for(;c>'9'||c<'0';f=c=='-',c=getchar());
for(;c>='0'&&c<='9';c=getchar())
x=(x<<1)+(x<<3)+c-'0';return f?-x:x;
}
inline void write(ll x){
if(x<0)putchar('-'),x=-x;
if(x>9)write(x/10);putchar(x%10+'0');
}
int n,a[N];
int dfs(int x){
int sm=0,i;
for(i=1;i<=n;i++)
sm^=a[i]&1;
if(sm!=(n&1))return x;
for(i=1;i<=n;i++)
if(a[i]&1&&a[i]>1)break;
a[i]--;
sm=a[1];
for(i=2;i<=n;i++)sm=__gcd(a[i],sm);
if(sm&1)return !x;
for(i=1;i<=n;i++)a[i]/=sm;
return dfs(!x);
}
int main(){
//freopen("1.out","w",stdout);
int i;
n=read();
for(i=1;i<=n;i++)a[i]=read();
puts(dfs(1)?"First":"Second");
return 0;
} | #include <bits/stdc++.h>
#define ALL(v) v.begin(), v.end()
#define MOD 1000000007
#define MAX 510000
#define Rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define rep(i, n) for(ll i = 1; i <= (ll)(n); i++)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
//cout << fixed << setprecision(10);//
//最小公倍数//
ll gcd(ll x, ll y) {
if (x == 0) return y;
return gcd(y%x, x);
}
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
//べき//
ll squ(ll n, ll p, ll m){
if(p==0) return 1;
if(p%2==0){
ll t=squ(n, p/2, m);
return t*t%m;
}
return n*squ(n,p-1,m);
}
//逆元mod(mを法とするaの逆元)//
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
//Cmonp//
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;
}
//nが大
ll com(ll n,ll m){
if(n<m || n<=0 ||m<0){
return 0;
}
if( m==0 || n==m){
return 1;
}
ll k=1;
for(ll i=1;i<=m;i++){
k*=(n-i+1);
k%=MOD;
k*=modinv(i,MOD);
k%=MOD;
}
return k;
}
////////////////////////////////////////////////////////////////////
ll a[100005];
int judge(int n){
ll y;
ll b[100005];
ll ch=0;
for(int i=1;i<=n;i++){
if(i==1){y=a[1];
if(y%2){y--;
ch=1;
}
}
else{
if(a[i]%2){
ch++;
y=gcd(y,a[i]-1);
}
else{
y=gcd(y,a[i]);
}
}
if(a[i]==1){return 0;}
if(ch>=2){return 0;}
}
if(ch==0){return 0;}
if(y==1||y%2==1){return 0;}
ll sum=0;
for(int i=1;i<=n;i++){
if(a[i]%2==0){
b[i]=a[i]/y;}
else{
b[i]=(a[i]-1)/y;
}
if((a[i]-b[i])%2)sum++;
}
if(sum%2){return 0;}
for(int i=1;i<=n;i++){
a[i]=b[i];
}
return 1;
}
int main() {
ll n;
cin>>n;
ll sum=0;
rep(i, n){
cin>>a[i];
sum+=a[i];
}
if(n%2==0){
if(sum%2==0){
cout<<"Second"<<endl;
}
else{
cout<<"First"<<endl;
}
return 0;
}
if(sum%2==0){cout<<"First"<<endl;
return 0;}
ll inv=0;
for(int u=1;u<=50;u++){
if(judge(n)==1){
inv++;
}
else{
break;
}
}
if(inv%2){cout<<"First"<<endl;}
else{cout<<"Second"<<endl;}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define maxn 100010
#define ll long long
using namespace std;
int n,m,vis[maxn];
ll ans[maxn],a[maxn],k,cnt,q[maxn],pos[maxn];
template <class T>
void read(T &x){
char s=getchar();int f=0;x=0;
while(s<'0'||s>'9'){if(s=='-') f=1;s=getchar();}
while(s>='0'&&s<='9') x=(x<<3)+(x<<1)+s-'0',s=getchar();
x=f?-x:x;
}
int main(){
read(n);
for(int i=1;i<=n;i++){
read(a[i]);
pos[i]=1ll*i;
}
read(m);read(k);
for(int i=n;i>=1;i--) a[i]=a[i]-a[i-1];
for(int i=1,x;i<=m;i++){
read(x);
swap(pos[x],pos[x+1]);
}
for(int i=1;i<=n;i++){
ll p=i;cnt=0;
if(vis[i]) continue;
q[++cnt]=p;
vis[p]=1;
p=pos[p];
while(p!=i){
q[++cnt]=p;
vis[p]=1;
p=pos[p];
}
for(int j=1;j<=cnt;j++) ans[q[j]]=a[q[(j+k-1)%cnt+1]];
}
for(int i=1;i<=n;i++){
ans[i]+=ans[i-1];
printf("%lld.0\n",ans[i]);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main () {
int d, g;
cin >> d >> g;
vector<pair<int,int>> p(d);
for (int i = 0; i < d; i++)
cin >> p[i].first >> p[i].second;
vector<int> v(d);
iota (v.begin(), v.end(), 0);
int ans = 1000;
do {
int sum = 0, c = 0;
for (int i = 0; i < d; i++) {
int x = v[i];
int i100 = 100 * (x+1);
int pi100 = p[x].first * i100;
if (g > sum + pi100 + p[x].second) {
sum += pi100 + p[x].second;
c += p[x].first;
}
else if (sum + pi100 <= g &&
g <= sum + pi100 + p[x].second) {
c += p[x].first;
break;
}
else {
c += (g - sum + i100-1) / i100;
break;
}
}
ans = min(ans, c);
}
while (next_permutation(v.begin(), v.end()));
cout << ans << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=1001000;
int fa[N],n,m,q[N],d[N],a[N],bl[N];
vector<int>g[N];
vector<pair<int,int> >vec[N];
int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
void add(int x,int y){g[x].push_back(y);g[y].push_back(x);}
int bfs(int S,int T){
for(int i=1;i<=n;++i)d[i]=-2;
d[S]=0;int t=-1,w=0;q[0]=S;
for(;t<w;){
int x=q[++t];
for(int i:g[x])if(d[i]==-2)d[i]=d[x]+1,q[++w]=i;
}
return d[T];
}
int main(){
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin>>n>>m;int S=1,T=n,mx=0;
for(int i=1;i<=m;++i){
int x,y,z;cin>>x>>y>>z;mx=max(mx,z);
vec[z].emplace_back(x,y);
}
for(int i=1;i<=mx;++i)if(!vec[i].empty()){
int cnt=0;
for(auto j:vec[i])a[++cnt]=j.first,a[++cnt]=j.second;
sort(a+1,a+cnt+1);cnt=unique(a+1,a+cnt+1)-a-1;
for(int j=1;j<=cnt;++j)fa[a[j]]=a[j];
for(auto j:vec[i])fa[find(j.first)]=find(j.second);
for(int j=1;j<=cnt;++j)if(fa[a[j]]==a[j])bl[a[j]]=++n;
for(int j=1;j<=cnt;++j)add(a[j],bl[find(a[j])]);
}
cout<<(bfs(S,T)/2)<<'\n';
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 233;
typedef long long ll;
int a[maxn],l[maxn],r[maxn],ord[maxn];
ll val[maxn],sum[maxn],tot = 0;
int n,x;
bool cmp(int i,int j){
return val[i]>val[j];
}
inline ll cal(int i,int v){
if(v<=a[i])return 1LL*v*l[i];
return 1LL*a[i]*l[i]+1LL*(v-a[i])*r[i];
}
bool check(ll m){
int t = (m-1)/x,v = m-t*x;
ll maxi = 0;
for(int i=1;i<=t;i++){
int x = ord[i];
ll tmp = sum[t+1] - val[x] + cal(x,v);
maxi = max(maxi,tmp);
}
for(int i=t+1;i<=n;i++){
ll tmp = sum[t] + cal(ord[i],v);
maxi = max(maxi,tmp);
}
if(maxi>=tot)return 1;
return 0;
}
int main()
{
cin>>n>>x;
for(int i=1;i<=n;i++)
scanf("%d%d%d",&a[i],&l[i],&r[i]),
val[i] = cal(i,x),
ord[i] = i,
tot += cal(i,a[i]);
// cout<<tot<<endl;
sort(ord+1,ord+n+1,cmp);
for(int i=1;i<=n;i++)
sum[i] = sum[i-1]+val[ord[i]];
ll l = 0,r = 1LL*n*x;
while(l!=r){
ll m = (l+r)>>1;
if(check(m))r = m;
else l = m+1;
}
cout << l << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,x,t;
cin>>n>>x>>t;
ll k=n/x,r=n%x;
if(r>0)r=1;
cout<<k*t+r*t;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define ll long long
#define P pair<ll,ll>
#define all(v) (v).begin(),(v).end()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1.0);
int main(void)
{
ll a,b,c; cin>>a>>b>>c;
if(a<c && c<b || b<c && c<a) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,j,k) for(int i = (int)(j);i <= (int)(k);i ++)
#define debug(x) cerr<<#x<<":"<<x<<endl
#define fix cout<<fixed<<setprecision(20);
const int maxn=(int)2e6+5;
vector<int> E[maxn];
int vis[maxn],ind[maxn],dis[maxn];
int reach[maxn];//longest can reach
inline int id(int x,int y){
if(x>y)swap(x,y);
//x--,y--;
return x+1000*y;
}
int ans=-1;
int dfs(int x){
//debug(x);
if(vis[x]==2)return dis[x];
vis[x]=1;
for(auto v:E[x]){
if(vis[v]==1)return -1;
//dis[v]=dis[x]+1;ans=max(ans,dis[v]);
int ret=dfs(v);
if(ret==-1)return -1;
dis[x]=max(dis[x],ret+1);//每个节点存最大值。
}
//debug(dis[x]);debug(x);
vis[x]=2;
return dis[x];
}
int main(){
//ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int n;cin>>n;
rep(i,1,n){
int last=0;
rep(j,1,n)if(i!=j){
int x;scanf("%d",&x);
if(last==0){last=id(i,x);continue;}
E[last].push_back(id(i,x));ind[id(i,x)]++;
last=id(i,x);
}
}
rep(i,1,n)rep(j,1,i-1)if(ind[id(i,j)]==0){
// memset(vis,0,sizeof(vis));
E[0].push_back(id(i,j));
/* dis[id(i,j)]=1;
if(dfs(id(i,j))==0){cout<<-1<<endl;return 0;};
//debug("--"); */
}
dis[0]=-1;
int ans=dfs(0);
cout<<ans<<endl;
}
/*
建DAG，判环
topo 可判环（无法进入队列的点），但无法找最长路径
两种环
一种是链环，用
一种是纯环，
3
2 3
1 3
1 2
12-13
12-23
13-23
4
2 3 4
1 3 4
4 1 2
3 1 2
12-13
13-14
12-23
23-24
34-13
13-23
34-14
14-24
queue<int> Q;
rep(i,1,n)rep(j,1,i-1)if(ind[id(i,j)]==0)Q.push(id(i,j)),vis[id(i,j)]=1;
while(!Q.empty()){
int cur=Q.front();Q.pop();
debug(cur);debug(vis[cur]);
for(auto v:E[cur]){
if(vis[v]){continue;}
//if(vis[v]==1){cout<<-1<<endl;return 0;}
ind[v]--;
if(ind[v]==0)Q.push(v),vis[v]=vis[cur]+1,ans=max(ans,vis[v]);
}
}
// rep(i,1,n)rep(j,1,n)if(i!=j)debug(vis[id(i,j)]),debug(i),debug(j);
*/ | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge=pair<int,int>;
using Graph=vector<vector<int>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return 1;}return 0;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
int N;
deque<int> A[1010];
int step[1010];
int M;
int main(){
cin>>N;
REP(i,N){
REP(j,N-1){
int x;
cin>>x;
A[i].push_back(x-1);
}
}
M=N*(N-1)/2;
queue<int> Q;
REP(i,N) Q.push(i);
int num=0;
while(Q.size()){
queue<int> Q2;
while(Q.size()){
int i=Q.front();
Q.pop();
if(step[i]<=num && A[i].size() && A[A[i].front()].front()==i && step[A[i].front()]<=num) {
step[i]=step[A[i].front()]=num+1;
Q2.push(i);
Q2.push(A[i].front());
A[A[i].front()].pop_front();
A[i].pop_front();
M--;
}
}
num++;
if(M==0) break;
swap(Q,Q2);
}
if(M) cout<<-1<<endl;
else cout<<num<<endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
long long int Min(long long int x,long long int y)
{
if(x<y)
return x;
return y;
}
int main()
{
long long int n,k,i,j,x;
long long int ans;
cin>>n>>k;
long long int ara[n];
for(i=0; i<n; i++)
cin>>ara[i];
if(ara[0]<0&&ara[n-1]<=0)
ans=(-1)*ara[0];
else if(ara[0]>=0 && ara[n-1]>0)
ans=ara[n-1];
else
ans=(ara[n-1]-ara[0]-ara[0]);
if(ara[0]>=0)
cout<<ara[k-1]<<endl;
else if(k==0)
cout<<0<<endl;
else
{
for(i=0; i<n; i++)
{
j=i+k-1;
if(j>n-1)
break;
if(ara[i]<0 && ara[j]>0){
x=Min(ara[j]-ara[i]-ara[i],-ara[i]+ara[j]+ara[j]);
ans=Min(ans,x);
}
else if(ara[i]<0 && ara[j]<=0)
ans=Min(ans,(-1)*ara[i]);
else
ans=Min(ans,ara[j]);
}
cout<<ans<<endl;
}
return 0;
}
| #include<iostream>
#include<queue>
#include<cmath>
#include<algorithm>
using namespace std;
int n,m,ans=0x3f3f3f3f;
int a[100000+5];
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
cin>>a[i];
}
for(int i=1;i<=n-m+1;i++){
int j=m+i-1;
ans=min(ans,min(abs(a[i])+abs(a[j]-a[i]),abs(a[j])+abs(a[j]-a[i])));
}
if(ans==0x3f3f3f3f) cout<<0<<endl;
cout<<ans<<endl;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
# define ll int64_t
# define str string
# define rep(i,n) for(ll i=0;i<n;i++)
# define rrep(i,n) for(ll i=1;i<=n;i++)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define mod 1000000007
# define PI 3.141592653589793
# define vec vector
#define dump(x) cerr<<#x<<"="<<x<<endl
using namespace std;
#define INF 2000000000
#define MAX_V 10
bool compare_by_b(pair<string,ll> a,pair<string,ll> b){
if(a.second != b.second) return a.second<b.second;
else return a.first<b.first;
}
bool my_compare(pair<ll,ll> a,pair<ll,ll> b){
if(a.first != b.first) return a.first<b.first;
if(a.second != b.second) return a.second>b.second;
else return true;
}
ll modpow(ll a,ll n,ll mod1) {
ll res=1;
while(n>0){
if(n&1) res=res*a%mod1;
a = a*a%mod1;
n >>= 1;
}
return res;
}
ll factorial(ll n){
ll x=1;
rrep(i,n) (x*=i)%=mod;
return x;
}
ll gcd(ll a,ll b) { return b ? gcd(b, a%b) : a; }
ll lcm(ll a,ll b){
return a/gcd(a,b)*b;
}
const ll MAX = 5100000;
const ll MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll 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;
}
using graph = vector<vector<ll>>;
pair<pair<ll,ll>,ll> p[100010];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,k;
cin>>n>>k;
vec<ll> a(n);
rep(i,n) {
cin>>a[i];
}
sort(ALL(a));
if(a[n-1]<k){
cout<<"IMPOSSIBLE"<<endl;
return 0;
}
ll sum=gcd(a[0],a[1]);
for(ll i=2;i<n;i++) sum=gcd(sum,a[i]);
if(k%sum==0) cout<<"POSSIBLE"<<endl;
else cout<<"IMPOSSIBLE"<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <numeric>
#define rep(i,n) for (int i = 0; i < n; ++i)
#define rep1(i,n) for (int i = 1; i <= n; ++i)
template<typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> inline T intceil(T a, T b) { return (a + (b - 1)) / b; }
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
const long long MOD = 1e9+7;
#define precout() cout << std::fixed << std::setprecision(20);
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
const int dy[4] = { 0, 1, 0, -1 };
const int dx[4] = { 1, 0, -1, 0 };
typedef complex<double> cd;
static const double pi = 3.141592653589793;
int gcd(int a, int b) {
if(b > a) swap(a, b);
if(a % b == 0) return b;
return gcd(b, a % b);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n,k; cin >> n >> k;
int curGcd; cin >> curGcd;
int maxA = curGcd;
rep(i, n - 1) {
int tmp; cin >> tmp;
chmax(maxA, tmp);
curGcd = gcd(curGcd, tmp);
}
if(k <= maxA && k % curGcd == 0) {
cout << "POSSIBLE" << endl;
} else {
cout << "IMPOSSIBLE" << 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;
const double PI = 3.14159265358979323846;
int main() {
vector<int> time(3);
vector<int> subsc = {0, 1, 2};
rep(i, 3) cin >> time[i];
int cmp = 100000000;
do {
int sum = 0;
rep(i, 2) sum += time[subsc[i]];
cmp = min(sum, cmp);
}while(next_permutation(subsc.begin(), subsc.end()));
cout << cmp << endl;
return 0;
}
| #include<iostream>
using namespace std;
int main(){
int d,a,b,s,sum;
while(cin>>d){
sum=0;
a=600/d;
for(int i=0;i<a;i++){
b=d*d*i*i;
s=b*d;
sum+=s;
}
cout << sum << endl;
}
return 0;
} | 0 |
#include <stdio.h>
int main() {
int H;
int W;
int N;
scanf("%d", &H);
scanf("%d", &W);
scanf("%d", &N);
int ctr = 0;
int total = 0;
while (N > total){
if(W >= H){
total += W;
ctr++;
}else if(H > W){
total += H;
ctr++;
}
}
printf("%d\n",ctr);
return 0;
} | #include <stdio.h>
int main() {
int rows, columns, n, tempR = 1, tempC = 1;
scanf("%d %d %d", &rows, &columns, &n);
int i = 1, j = 1;
while(tempR < n && i <= rows) {
tempR = i * columns;
i++;
}
while(tempC < n && j <= columns) {
tempC = j * rows;
j++;
}
if(i == 1 && j == 1) printf ("1");
else if(i < j) printf("%d", i - 1);
else printf("%d", j - 1);
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=4005,mod=998244353;
int k,n,c[N][N];
ll C(int n,int m)
{
if(m==0||n==m) return 1;
if(m==1) return n;
if(c[n][m]) return c[n][m];
return c[n][m]=(C(n-1,m-1)+C(n-1,m))%mod;
}
ll solve(int x)
{
ll ans=0;
int up=0;
for(int i=1;i<=x/2;i++)
if(i<=k&&x-i<=k)
up++;
for(int j=0,f=1;j<=up&&n-2*j>=0;j++,f*=-1)
ans=(ans+f*C(up,j)%mod*C(n-2*j+k-1,k-1))%mod;
return (ans+mod)%mod;
}
int main()
{
scanf("%d%d",&k,&n);
for(int i=2;i<=2*k;i++)
printf("%lld\n",solve(i));
}
| #include <bits/stdc++.h>
using namespace std;
#define SPEED ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define fileio freopen("in.in", "r", stdin),freopen("out.out", "w", stdout);
#define ll long long int
#define FF first
#define SS second
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define pll pair<long long int,long long int>
#define sd(x) scanf("%d",&x)
#define slld(x) scanf("%lld",&x)
#define pd(x) printf("%d\n",x)
#define plld(x) printf("%lld\n",x)
#define pss printf
#define MOD 998244353
#define INF 1e18
#define eps 0.00001
#define endl '\n'
#define debug(n1) cout<<n1<<endl
int n,k;
ll dp[2005][2005];
ll pre[2005];
ll dp1[2005][2005];
int rec(int i,int j)
{
return dp[i][j];
}
int rec1(int i,int j)
{
if(j==0)
return 1;
if(i==0)
return (j==0);
if(dp1[i][j]!=-1)
return dp1[i][j];
int an=(rec1(i-1,j)+rec1(i,j-1))%MOD;
return dp1[i][j]=an;
}
int main()
{
SPEED;
cin>>k>>n;
dp[0][0]=1;
pre[0]=1;
for(int j=1;j<=n;j++)
pre[j]=(pre[j-1]+dp[0][j])%MOD;
for(int i=1;i<=k;i++)
{
dp[i][0]=1;
for(int j=1;j<=n;j++)
dp[i][j]=(dp[i-1][j]+2*pre[j-1])%MOD;
pre[0]=dp[i][0];
for(int j=1;j<=n;j++)
pre[j]=(pre[j-1]+dp[i][j])%MOD;
}
memset(dp1,-1,sizeof dp1);
for(int i=2;i<=2*k;i++)
{
ll ans=0;
int moves=0;
if(i%2)
{
if(i<=k)
moves=i/2;
else
moves=i/2-(i-k)+1;
for(int j=0;j<=n;j++)
{
ll x=rec(moves,j);
ll y=rec1(k-2*moves,n-j);
ans=(ans+x*y)%MOD;
}
}
else
{
if(i<=k)
moves=(i-1)/2;
else
moves=(i-1)/2 - (i-k-1);
for(int j=0;j<=n;j++)
{
ll x=rec(moves,j);
ll y=rec1(k-2*moves-1,n-j);
ans=(ans+x*y)%MOD;
y=0;
if(n-j-1>=0)
y=rec1(k-2*moves-1,n-j-1);
ans=(ans+x*y)%MOD;
}
}
cout<<ans<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int,int>,int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
const int MAX = 1000000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int main()
{
cout << fixed << setprecision(15);
ll N, M, K;
cin >> N >> M >> K;
ll A = 1;
A = (A*N)%MOD;
A = (A*N)%MOD;
A = (A*(M-1))%MOD;
A = (A*M)%MOD;
A = (A*(M+1))%MOD;
ll B = 1;
B = (B*M)%MOD;
B = (B*M)%MOD;
B = (B*(N-1))%MOD;
B = (B*N)%MOD;
B = (B*(N+1))%MOD;
// 前処理
COMinit();
ll C = COM(N*M-2, K-2) % MOD;
cout << ((((A+B)%MOD)* modinv(6, MOD) % MOD) * C) % MOD << endl;
return 0;
} | #pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define FAST_IO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define mod 1000000007
#define endl "\n"
#define PI 3.14159265358979323846264338327950288
using namespace std ;
using bigint = long long int ;
using vi = vector<int> ;
using vll = vector<long long int> ;
int pref[1000075] ;
int main(){
FAST_IO ;
int D , T , S ; cin >> D >> T >> S ;
if( S * T >= D )
cout << "Yes" << endl ;
else
cout << "No" << endl ;
return 0 ;
}
| 0 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second
/* clang-format off */
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
/* clang-format on */
const ll MOD = 1e9 + 7;
int main() {
#ifdef DEBUG
ifstream cin("in.txt");
#endif
int N, X;
while (cin >> N >> X) {
vector<int> S(N);
for (int i = 0; i < N; i++) cin >> S[i];
sort(S.begin(), S.end());
vector<ll> dp(X + 1, 0);
for (ll x = 0; x <= X; x++) dp[x] = x;
for (int i = 0; i < N; i++) {
int m = S[i];
vector<ll> ndp(X + 1, 0);
for (ll x = 0; x <= X; x++) {
ndp[x] = (dp[x] * i % MOD + dp[x % m]) % MOD;
}
dp.swap(ndp);
}
cout << dp[X] << endl;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,count=0,i,temp,sum;
cin>>a>>b;
for(i=a;i<=b;i++)
{
sum=0;
temp = i;
while(temp)
{
sum*=10;
sum+=(temp%10);
temp/=10;
}
if(sum==i)
count++;
}
cout<<count<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using P = pair<int, int>;
#define roop(i, n) for(int i = 0;i < n;i++)
int main(void){
string str;
cin >> str;
int al[26] = {0};
roop(i, str.length()) al[str[i]-'a']++;
roop(i, 26){
if(al[i] == 0){
str += (char)(i+'a');
cout << str << endl;
return 0;
}
}
string t = str;
if(next_permutation(t.begin(), t.end()) == false){
cout << -1 << endl;
return 0;
}
roop(i, str.length()-1){
cout << t[i];
if(t[i] != str[i]) break;
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void)
{
string s;
cin >> s;
bool flag = false;
for(int i = 0; i < s.size()-1; ++i)
{
if(s[i] == s[i+1])
{
cout << i+1 << " " << i+2 << endl;
return 0;
}
if(i+2 < s.size() && s[i] == s[i+2])
{
cout << i+1 << " " << i+3 << endl;
return 0;
}
}
cout << -1 << " " << -1 << endl;
return 0;
}
| 0 |
Subsets and Splits