text
stringlengths 49
983k
|
|---|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
int N,M,A,B,P,Q;
void dfs(int k,int n,int s,vint &v,vint &latte){
if(k==n){
latte.pb(s);
return;
}
dfs(k+1,n,s,v,latte);
dfs(k+1,n,s+v[k],v,latte);
}
signed main(){
cin>>N>>M>>A>>B>>P>>Q;
if(A==1&&B==1){
P+=Q;
int ans=M;
if(M/P>N)chmin(ans,abs(M-P*N));
else{
chmin(ans,abs(M-M/P*P));
if(M/P+1<=N)chmin(ans,abs(M-M/P*P-P));
}
cout<<ans<<endl;
return 0;
}
vector<int>v;
int x=P,y=Q;
for(int i=0;i<N;i++){
v.pb(x+y);
if(1.0*x*A>1e15||1.0*y*B>1e15||x+y>M)break;
x*=A;y*=B;
}
int n=v.size()/2;
vint latte,malta;
dfs(0,n,0,v,latte);
dfs(n,v.size(),0,v,malta);
sort(all(latte));
sort(all(malta));
int ans=M;
int cur=latte.size()-1;
for(int i=0;i<malta.size();i++){
while(cur&&latte[cur]+malta[i]>M)cur--;
chmin(ans,abs(M-latte[cur]-malta[i]));
}
cur=0;
for(int i=(int)malta.size()-1;i>=0;i--){
while(cur+1!=latte.size()&&latte[cur]+malta[i]<M)cur++;
chmin(ans,abs(M-latte[cur]-malta[i]));
}
cout<<ans<<endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cassert>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define FOR(i, a, b) for (ll i = (a); i < (ll)(b); ++i)
#define FOREQ(i, a, b) for (ll i = (a); i <= (ll)(b); ++i)
#define DEC(i, k) for (ll i = (k); i >= 0; --i)
#define FORIT(i, c) for (__tyoeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define SZ(v) (ll)((v).size())
#define MEMSET(v, h) memset((v), (h), sizeof(v))
#define FIND(m, w) ((m).find(w) != (m).end())
#define ALL(c) (c).begin(), (c).end()
ll ticket[1000];
ll ticketSum[1000];
ll n, m, a, b, p, q;
ll cnt;
ll calc(ll depth, ll lm) {
if (depth == cnt || lm <= 0) { return abs(lm); }
if (ticketSum[depth] < lm) { return abs(lm - ticketSum[depth]); }
ll ret = m;
ret = min(ret, calc(depth + 1, lm));
ret = min(ret, calc(depth + 1, lm - ticket[depth]));
return ret;
}
int main() {
cin >> n >> m >> a >> b >> p >> q;
if (a == 1 && b == 1) {
ll use = m / (p + q);
use = min(use, n - 1);
printf("%lld\n", min(m - use * (p + q), abs(m - (use + 1) * (p + q))));
return 0;
}
cnt = 0;
{
ll left = p;
ll right = q;
REP(i, n) {
if (left + right > 2 * m) { break; }
ticket[cnt++] = left + right;
ll pleft = left;
ll pright = right;
left *= a;
right *= b;
if (left / a != pleft || right / b != pright) { break; }
}
}
reverse(ticket, ticket + cnt);
MEMSET(ticketSum, 0);
for (ll i = cnt; i > 0; i--) {
ticketSum[i - 1] = ticket[i - 1] + ticketSum[i];
}
ll ans = calc(0, m);
printf("%lld\n", ans);
}
|
// g++ -std=c++11 a.cpp
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<unordered_map>
#include<utility>
#include<cmath>
#include<random>
#include<cstring>
#include<queue>
#include<stack>
#include<bitset>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#include<typeinfo>
#define loop(i,a,b) for(ll i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define FOR(i,a) for(auto i:a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define show1d(v) rep(i,v.size())cout<<" "<<v[i];cout<<endl<<endl;
#define show2d(v) rep(i,v.size()){rep(j,v[i].size())cout<<" "<<v[i][j];cout<<endl;}cout<<endl;
using namespace std;
//kaewasuretyuui
typedef long long ll;
//#define int ll
typedef ll Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
#define mt make_tuple
typedef tuple<int,int,int,int> tp;
typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
//template<class C>constexpr int size(const C &c){return (int)c.size();}
//template<class T,size_t N> constexpr int size(const T (&xs)[N])noexcept{return (int)N;}
const double PI=acos(-1);
const double EPS=1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9+10;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int main(){
ll n,m,a,b,p,q;
cin>>n>>m>>a>>b>>p>>q;
if(a+b==2){
ll t=p+q;
ll T=min(n,m/t);
ll out=m;
loop(i,max(0ll,T-10),min(n+1,T+10))
out=min(out,abs(t*i-m));
cout<<out<<endl;
return 0;
}
vi A,B;
ll t=p;
int co=0;
while(1){
A.pb(t);
if(to_string(t).size()+to_string(a).size()>16)break;
t*=a;
if(a==1&&co==40)break;
co++;
}
t=q;
co=0;
while(1){
B.pb(t);
if(to_string(t).size()+to_string(b).size()>16)break;
t*=b;
if(b==1&&co==40)break;
co++;
}
//show1d(A);
//show1d(B);
vi in;
rep(i,min((ll)A.size(),n))
if(i<B.size()&&A[i]+B[i]<=3*m)in.pb(A[i]+B[i]);
n=in.size()/2;
ll N=1<<n;
vi dp;
rep(i,N){
ll sum=0;
rep(j,n)if(i&1<<j)sum+=in[j];
if(sum<=3*m)dp.pb(sum);
}
sort(all(dp));
ll nn=in.size()-n;
N=1<<nn;
ll out=m;
// show1d(in);
rep(i,N){
ll sum=0;
rep(j,nn)if(i&1<<j)sum+=in[n+j];
if(sum>3*m)continue;
auto it=upper_bound(all(dp),m-sum);
if(it!=dp.end())out=min(out,abs(*it+sum-m));
if(it==dp.begin())continue;
it--;
out=min(out,abs(*it+sum-m));
}
// show1d(dp);
cout<<out<<endl;
}
|
#include<stdio.h>
#include<algorithm>
using namespace std;
long long dist[40];
int main(){
long long a,b,c,d,e,f;
scanf("%lld%lld%lld%lld%lld%lld",&a,&b,&c,&d,&e,&f);
if(c==1&&d==1){
long long v=b%(e+f);
long long g=b/(e+f);
long long ret=v+max(0LL,g-a)*(e+f);
g++;
v=e+f-v;
ret=min(ret,v+max(0LL,g-a)*(e+f));
printf("%lld\n",ret);
return 0;
}
int sz=0;
for(int i=0;i<a;i++){
long long L=e;
long long R=f;
long long Q=b;
for(int j=0;j<i;j++)Q/=max(c,d);
if(Q==0)break;
for(int j=0;j<i;j++)L*=c;
for(int j=0;j<i;j++)R*=d;
long long t=L+R;
if(t>b*2)break;
dist[sz++]=t;
// printf("%lld ",dist[sz-1]);
}
if(d==1){
swap(c,d);
swap(e,f);
}
if(c==1){
long long ret=b;
for(int i=0;i<sz;i++)dist[i]-=e;
for(int i=1;i<=sz;i++){
long long tmp=b-(long long)i*e;
if(tmp<0)break;
int rem=i;
for(int j=sz-1;j>=0;j--){
if(tmp>=dist[j]){
rem--;
tmp-=dist[j];
}else{
long long cost=dist[j]-tmp;
if(rem-1<=j){
for(int k=0;k<rem-1;k++){
cost+=dist[k];
}
// printf("%d %d: %lld\n",i,j,cost);
ret=min(ret,cost);
}
}
if(rem==0)break;
}
if(rem==0)ret=min(ret,tmp);
//printf("%d: %lld\n",i,ret);
}
printf("%lld\n",ret);
return 0;
}
long long ret=b;
long long tmp=b;
for(int i=sz-1;i>=0;i--){
if(tmp>=dist[i])tmp-=dist[i];
else ret=min(ret,dist[i]-tmp);
ret=min(ret,tmp);
}
printf("%lld\n",ret);
}
//11 12 14 18
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = mod*mod;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
//t個が1,x以下とx以上を求める
LP calc(ll x, int t,int sup=40) {
vector<int> v;
rep(i, sup) {
ll k = (ll)1 << i;
if (x&k)v.push_back(i);
}
int len = v.size();
ll le = 0;
if (t <= len) {
for (int i = len - 1; i >= len - t; i--) {
le += (ll)1 << v[i];
}
}
else {
bool f = false;
rep(i, len) {
int cnt = v[i];
cnt += len - 1 - i;
if (cnt >= t) {
for (int j = len - 1; j > i; j--) {
le += (ll)1<<v[j];
}
int r = t - (len - 1 - i);
rep(j, r) {
le += (ll)1 << j;
}
f = true;
break;
}
}
if (!f)le = -INF;
}
ll ri = 0;
if (t <= len) {
int tmp = len;
rep(i, sup) {
ll k = (ll)1 << i;
if (k&x) {
tmp--; continue;
}
int cnt = i;
cnt += tmp;
cnt++;
if (tmp + 1 <= t && cnt >= t) {
ri += k;
Rep(j, len-tmp, len) {
ri += (ll)1 << v[j];
}
int r = t - (tmp + 1);
rep(j, r) {
ri += (ll)1 << j;
}
break;
}
}
}
else {
rep(i, len) {
ri += (ll)1 << v[i];
}
int r = t - len;
rep(j, sup) {
if (r == 0)break;
ll k = (ll)1 << j;
if ((x&k) == 0) {
ri += k; r--;
}
}
}
return { le,ri };
}
string add(string a, string b) {
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
int len = max(a.length(), b.length());
int rest = 0; string res;
rep(i, len + 1) {
if (i < (int)a.length()) {
rest += a[i] - '0';
}
if (i < (int)b.length()) {
rest += b[i] - '0';
}
res.push_back('0' + (rest % 10));
rest /= 10;
}
while (res.length() && res[res.length() - 1] == '0')res.erase(res.end() - 1);
reverse(res.begin(), res.end());
return res;
}
string multi0(int m, string a) {
string res;
reverse(a.begin(), a.end());
int len = a.length();
int rest = 0;
rep(i, len) {
rest += m * (a[i] - '0');
res.push_back('0' + (rest % 10));
rest /= 10;
}
if (rest)res.push_back('0' + rest);
reverse(res.begin(), res.end());
return res;
}
string multi(string a, string b) {
int len = a.length(); string res = "0";
per(i, len) {
int t = a[i] - '0'; int rest = len - i - 1;
string nex = multi0(t, b);
rep(j, rest) {
nex.push_back('0');
}
res = add(res, nex);
}
return res;
}
bool invalid(ll a,ll p) {
string s = to_string(a); string t = to_string(p);
string st = multi(s, t);
if (st.size() >= 15)return true;
else return false;
}
void solve() {
ll n, m, a, b, p, q; cin >> n >> m >> a >> b >> p >> q;
if (a > b) {
swap(a, b); swap(p, q);
}
ll ans = INF;
if (invalid(a, p) || invalid(b, q)) {
ans = m;
ans = min(ans, abs(m - p - q));
}
else if (invalid(a,a)||invalid(b,b)) {
//cout << "hello" << endl;
ans = min(ans, m);
ans = min(ans, abs(m - p - q));
if (n > 1) {
ans = min(ans, abs(m - p * a - q * b));
ans = min(ans, abs(m - p * a - q * b - p - q));
}
}
else if (a == 1 && b == 1) {
ll le = m / (p + q);
if (n < le) {
ll sum = (p + q)*n;
ans = min(ans, m - sum);
}
else {
ans = min(ans, m - (p + q)*le);
}
if (n >= le + 1) {
ans = min(ans, (p + q)*(le + 1) - m);
}
}
else if (a == 1 && b == 2) {
ll x = a, y = b;
rep(i, n) {
ll sum = p * x + q * y;
if (sum >= m) {
ans = min(ans, sum - m); break;
}
x = x * a; y = y * b;
}
ll s = min(n, (ll)40);
//i個使う
rep1(i, s) {
ll mm = m - i * p;
ll d = mm / q;
LP z = calc(d, i, s);
if (z.first != -INF) {
ans = min(ans, abs(mm - q * z.first));
}
ans = min(ans, abs(mm - q * z.second));
//ll lesum = q * z.first, risum = q * z.second;
//cout << lesum + i * p << " i " << risum + i * p << endl;
//ans = min(ans, abs(mm - lesum));
//ans = min(ans, abs(risum - mm));
}
}
else if (a == 2 && b == 2) {
ll d = m / (p + q);
ll s = min(n, (ll)40);
ll z = 0;
rep(i, s) {
z += (ll)1 << i;
}
if (z < m)ans = min(ans, m - z * (p + q));
else {
ll le = d;
ans = min(ans, m - le * (p + q));
le++;
ll las = 0;
rep(i, 40) {
ll k = (ll)1 << i;
if (k&le) {
las = i;
}
}
if (las < n) {
ans = min(ans, m - le * (p + q));
}
}
}
else {
ll x = 1, y = 1;
vector<ll> v;
rep(i, n) {
ll sum = p * x + q * y;
if (sum >= m) {
ans = min(ans, sum - m);
break;
}
v.push_back(sum);
x = x * a; y = y * b;
}
int len = v.size();
ll sum = 0;
per(i, v.size()) {
if (sum + v[i] <= m) {
sum += v[i];
}
else {
ans = min(ans, abs(m - sum-v[i]));
}
}
ans = min(ans, abs(m - sum));
/*cout << len << endl;
rep(i, (1 << len)) {
ll u = 0;
rep(j, len) {
if (i&(1 << j))u += v[j];
}
ans = min(ans, abs(m - u));
}*/
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
//stop
return 0;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int main(){
long long int n, m, a, b, p, q, ans;
cin >> n >> m >> a >> b >> p >> q;
if(a < b){
swap(a, b);
swap(p, q);
}
if(a == 1LL){
if(m/(p + q) >= n) cout << m - n*(p + q) << endl;
else{
long long int t = m - m/(p + q)*(p + q);
cout << min(t, p + q - t) << endl;
}
return 0;
}
ans = m;
long long int x = 1LL, y = 1LL;
for(int i = 1; i < n; ++i){
if(m <= p*x + q*y) break;
if(x > (1LL<<40)/a || y > (1LL<<40)/b) break;
x *= a;
y *= b;
}
while(x > 0){
ans = min(ans, abs(m - (p*x + q*y)));
if(m >= p*x + q*y) m -= p*x + q*y;
x /= a;
y /= b;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
int main(){
ll n,m,a,b,p,q;
cin >> n >> m >> a >> b >> p >> q;
if(a == 1 && b == 1){
ll x = m/(p+q);
if(x >= n)cout << m-n*(p+q) << endl;
else cout << min ( m-x*(p+q) , (x+1)*(p+q)-m ) << endl;
}
else {
vector<ll> vec;
ll s = 1 , t = 1;
for(int i = 0 ; i < n ; i ++){
vec.push_back(p*s+q*t);
if(p*s+q*t > m)break;
s *= a;
t *= b;
}
int N = vec.size();
vector<ll> A,B;
A.push_back(0);
for(int i = 0 ; i < N/2 ; i ++){
int x = A.size();
for(int j = 0 ; j < x ; j ++){
A.push_back(vec[i]+A[j]);
}
}
B.push_back(0);
for(int i = N/2 ; i < N ; i ++){
int x = B.size();
for(int j = 0 ; j < x ; j ++){
B.push_back(vec[i]+B[j]);
}
}
sort(B.begin(),B.end());
B.erase(unique(B.begin(),B.end()),B.end());
ll ret = m;
for(int i = 0 ; i < A.size() ; i ++){
int x = upper_bound(B.begin(),B.end(),m-A[i])-B.begin();
if(x < B.size())ret = min ( ret , A[i]+B[x]-m );
x --;
ret = min ( ret , m-A[i]-B[x] );
}
cout << ret << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template <typename T>
bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
//const ll mod = 1000000007;
ll n, m, a, b, p, q;
ll ans = 1e18;
void solve1() {
ll timer = m / (p + q);
chmin(timer, n);
chmin(ans, abs(m - timer * (p+q)));
timer++;
chmin(timer, n);
chmin(ans, abs(m - timer * (p+q)));
return;
}
void solve2() {
ll Mindex = 0;
ll pak = p;
ll qbk = q;
for(ll i = 1; i < n; i++) {
if(pak > 1e15 / a) break;
if(qbk > 1e15 / b) break;
chmax(Mindex, i);
pak *= a;
qbk *= b;
}
ll rest = m;
while(Mindex >= 0) {
//cerr << Mindex << " " << rest << " " << pak << " " << qbk << endl;
chmin(ans, abs(rest - pak - qbk));
if(rest - pak - qbk >= 0) {
rest -= pak + qbk;
chmin(ans, rest);
}
pak /= a;
qbk /= b;
Mindex--;
}
}
void solve3() {
ll Mindex = 0;
ll qbk = q;
for(ll i = 1; i < n; i++) {
if(qbk > 1e15 / b) break;
chmax(Mindex, i);
qbk *= b;
}
for(int num = 1; num <= Mindex + 1; num++) {
ll rest = m - num * p;
ll restnum = num;
ll nowqbk = qbk;
for(int j = Mindex; j >= 0; j--) {
if(j + 1 == restnum or (restnum >= 1 and rest - nowqbk >= 0)) {
rest -= nowqbk;
restnum--;
} else {
/*
ll nowrest = rest;
rest -= nowqbk;
ll nowrestnum = restnum - 1;
ll newqbk = q;
for(ll i = 0; i < nowrestnum; i++) {
rest -= newqbk;
newqbk *= b;
}
*/
//chmin(ans, abs(nowrest));
}
nowqbk /= b;
}
chmin(ans, abs(rest));
}
}
int main() {
//cout.precision(10);
cin >> n >> m >> a >> b >> p >> q;
ans = m;
if(a == 1 and b == 1) {
solve1();
} else if(a != 1 and b != 1) {
solve2();
} else {
if(a != 1) {
swap(a, b);
swap(p, q);
}
solve3();
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll INF=10000000000000000LL;
ll mul(ll a,ll b){
if(a>INF/b)return INF;
return a*b;
}
ll n,m,a,b,p,q;
void dfs(ll x,ll sum,vector<ll> &t,vector<ll> &T){
if(x==(int)t.size()){
T.push_back(sum);
}else{
dfs(x+1,sum,t,T);
dfs(x+1,min(INF,sum+t[x]),t,T);
}
}
ll solve(){
ll MAX=1000000000000LL;
assert( 1<= n &&n <= MAX );
assert( 1<= m &&m <= MAX );
assert( 1<= a &&a <= MAX );
assert( 1<= b &&b <= MAX );
assert( 1<= p &&p <= MAX );
assert( 1<= q &&q <= MAX );
if(a==1 && b==1){
ll d=p+q;
ll total=mul(d,n);
if(total <= m)return m-total;
return min(m%d,d-m%d);
}
vector<ll> t, u;
ll ak=1,bk=1;
for(int i=0;i<n;i++){
if(i&1)t.push_back( mul(ak,p) + mul(bk,q) );
else u.push_back( mul(ak,p) + mul(bk,q) );
ak=mul(ak,a);
bk=mul(bk,b);
if( i==40 )break;
}
vector<ll> T,U;
dfs(0,0,t,T);
dfs(0,0,u,U);
sort(T.begin(),T.end());
sort(U.begin(),U.end());
ll res=m;
for(int i=0;i<(int)T.size();i++){
ll target=m-T[i];
int index=lower_bound(U.begin(),U.end(),target)-U.begin();
for(int j=index-2;j<=index+2;j++){
if(0<=j && j<(int)U.size()){
ll c=T[i]+U[j];
res=min( res, abs(m-c) );
}
}
}
return res;
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
cout<<solve()<<endl;
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int main(){
int POW[22];
for(int i = 0; i < 22; i++)POW[i] = pow(2,i);
ll N,M,A,B,P,Q;
scanf("%lld %lld %lld %lld %lld %lld",&N,&M,&A,&B,&P,&Q);
if(A == 1 && B == 1){
ll num = M/(P+Q);
if(num >= N){
printf("%lld\n",M-N*(P+Q));
}else{
printf("%lld\n",min(M%(P+Q),(num+1)*(P+Q)-M)); //少し足りないと、少し多いの、差が小さい方
}
return 0;
}
vector<ll> FIRST;
ll tmp = P+Q;
ll a = 1, b = 1;
ll count = 0,over_count = 0;
double check;
while(true){
if(tmp > M)over_count++; //超過は1回だけ許す
FIRST.push_back(tmp);
count++;
if(count == N || over_count == 1)break;
check = P*a*A+Q*b*B;
if(check > (double)M)break;
a *= A;
b *= B;
tmp = P*a+Q*b;
}
//printf("count:%lld\n",count);
//数字を2つのグループに振り分ける
vector<ll> G[2];
for(ll i = 0; i < FIRST.size(); i++){
if(i <= (FIRST.size())/2){
G[0].push_back(FIRST[i]);
}else{
G[1].push_back(FIRST[i]);
}
}
int num[2];
num[0] = (int)G[0].size();
num[1] = (int)G[1].size();
//printf("num_0:%d\n",num[0]);
//各グループで数字を作る
vector<ll> V[2];
V[1].push_back(0);
for(int group = 0; group < 2; group++){
for(int state = 0; state < POW[num[group]]; state++){
tmp = 0;
for(int loop = 0; loop < num[group]; loop++){
if(state & (1 << loop)){
tmp += G[group][loop];
}
}
V[group].push_back(tmp);
}
sort(V[group].begin(),V[group].end());
V[group].erase(unique(V[group].begin(),V[group].end()),V[group].end());
}
ll ans = M,tmp_ans;
int left,right,m,loc;
for(int i = 0; i < V[0].size(); i++){
if(V[0][i] >= M){
ans = min(ans,V[0][i]-M);
break;
}
//2分探索で、和がMを超えない、最大のindexを求める
left = 0,right = (int)V[1].size()-1,m = (left+right);
loc = 0;
while(left <= right){
if(V[0][i]+V[1][m] <= M){
loc = m;
left = m+1;
}else{
right = m-1;
}
m = (left+right)/2;
}
tmp_ans = (M-(V[0][i]+V[1][loc]));
if(loc < (int)V[1].size()-1){
tmp_ans = min(tmp_ans,V[0][i]+V[1][loc+1]-M);
}
//printf("i:%d tmp_ans:%lld\n",i,tmp_ans);
ans = min(ans,tmp_ans);
}
printf("%lld\n",ans);
return 0;
}
|
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<list>
#include<bitset>
#include<stack>
#include<memory>
#include<numeric>
using namespace std;
using namespace std::chrono;
typedef long long int llint;
typedef long double lldo;
#define mp make_pair
#define mt make_tuple
#define pub push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define fir first
#define sec second
#define res resize
#define ins insert
#define era erase
/*cout<<fixed<<setprecision(20);cin.tie(0);ios::sync_with_stdio(false);*/
const llint mod=1000000007 ;
const llint big=2.19e15+1;
const long double pai=3.141592653589793238462643383279502884197;
const long double eps=1e-10;
const long double epsA=1e-4;
template <class T,class U>bool mineq(T& a,U b){if(a>b){a=b;return true;}return false;}
template <class T,class U>bool maxeq(T& a,U b){if(a<b){a=b;return true;}return false;}
llint gcd(llint a,llint b){if(a%b==0){return b;}else return gcd(b,a%b);}
llint lcm(llint a,llint b){if(a==0){return b;}return a/gcd(a,b)*b;}
template<class T> void SO(T& ve){sort(ve.begin(),ve.end());}
template<class T> void REV(T& ve){reverse(ve.begin(),ve.end());}
template<class T>llint LBI(const vector<T>&ar,T in){return lower_bound(ar.begin(),ar.end(),in)-ar.begin();}
template<class T>llint UBI(const vector<T>&ar,T in){return upper_bound(ar.begin(),ar.end(),in)-ar.begin();}
int main(void){
//ウサギは進みすぎた後徒歩で戻ってもいいんか
//いったんすべてを決定した後、キャンセルする手法
llint n,m,a,b,p,q,i;cin>>n>>m>>a>>b>>p>>q;
llint ans=m;
if(a>b){swap(p,q);swap(a,b);}
if(a==1&&b==1){
llint f=min(n,m/(p+q));
llint fx=min(n,m/(p+q)+1);
cout<<min(m-f*(p+q),abs(m-fx*(p+q)))<<endl;
}else{
//とりあえずnをfixする
llint pg=p,qg=q,aa=0;
while(pg+qg<=m*3){
aa++;
if(1.0*pg*a+1.0*qg*b>m*4){break;}//オーバーフロー危ない！
pg*=a;qg*=b;
}
mineq(n,aa);
//cerr<<"n="<<n<<endl;
if(a==1){
//cerr<<"a"<<endl;
//合計枚数を固定して、そこから求める
llint mai[80];
qg=q;
llint wa=0;
for(i=0;i<n;i++){mai[i]=qg;wa+=mai[i];qg*=b;}
wa+=n*p;
for(int h=0;h<=n;h++){
//枚数を固定する
llint gen=m-h*p;
for(i=0;i<h;i++){gen-=mai[i];}
//maiでうまく貪欲法
llint rest=h;
for(i=n-1;i>=0;i--){
if(rest<=0){break;}
if(i<rest){break;}
if(gen>=mai[i]-mai[rest-1]){gen-=mai[i]-mai[rest-1];rest--;}
}
mineq(ans,abs(gen));
gen=wa-(m-h*p);
for(i=0;i<h;i++){gen-=mai[i];}
if(gen<0){continue;}
//maiでうまく貪欲法
rest=h;
for(i=n-1;i>=0;i--){
if(rest<=0){break;}
if(i<rest){break;}
if(gen>=mai[i]-mai[rest-1]){gen-=mai[i]-mai[rest-1];rest--;}
}
mineq(ans,abs(gen));
}
cout<<ans<<endl;
}else{
llint mai[80];
qg=q;pg=p;
llint wa=0;
for(i=0;i<n;i++){mai[i]=qg+pg;wa+=mai[i];pg*=a;qg*=b;}
llint gen=m;
for(i=n-1;i>=0;i--){
//cerr<<"gen="<<gen<<endl;
if(gen>=mai[i]){gen-=mai[i];}
}
mineq(ans,abs(gen));
gen=wa-m;
for(i=n-1;i>=0;i--){
//cerr<<"gen="<<gen<<endl;
if(gen>=mai[i]){gen-=mai[i];}
}
mineq(ans,abs(gen));
cout<<ans<<endl;
}
}
return 0;
}
/*
1 2 4 8 16
10000000000
*/
|
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
//INSERT ABOVE HERE
signed main(){
using i128 = __int128_t;
Int n,m,a,b,p,q;
cin>>n>>m>>a>>b>>p>>q;
i128 N(n),M(m),A(a),B(b),P(p),Q(q);
auto calc=[&](i128 a,i128 b)->i128{return a<=b?b-a:a-b;};
if(a==1&&b==1){
i128 need=M/(P+Q);
if(need<=N){
i128 ans=calc(M,need*(P+Q));
if(need-1>=0) chmin(ans,calc(M,(need-1)*(P+Q)));
if(need+1<=N) chmin(ans,calc(M,(need+1)*(P+Q)));
cout<<Int(ans)<<endl;
return 0;
}
cout<<Int(M-N*(P+Q))<<endl;
return 0;
}
vector<i128> vs;
for(Int i=0;i<n;i++){
vs.emplace_back(P+Q);
if(P+Q>M) break;
P*=A;
Q*=B;
}
const Int H = 20;
i128 ans=M;
vector<i128> hs;
for(Int bit=0;bit<(1LL<<H);bit++){
i128 tmp=0;
for(Int i=0;i<(Int)vs.size();i++){
if((~bit>>i)&1) continue;
tmp+=vs[i];
}
hs.emplace_back(tmp);
chmin(ans,calc(M,tmp));
}
sort(hs.begin(),hs.end());
hs.erase(unique(hs.begin(),hs.end()),hs.end());
if(vs.size()>H){
Int R=vs.size()-H;
for(Int bit=0;bit<(1LL<<R);bit++){
i128 tmp=0;
for(Int i=H;i<(Int)vs.size();i++){
if((~bit>>(i-H))&1) continue;
tmp+=vs[i];
}
auto it=upper_bound(hs.begin(),hs.end(),M-tmp);
if(it!=hs.end()) chmin(ans,calc(M,tmp+*it));
++it;
if(it!=hs.end()) chmin(ans,calc(M,tmp+*it));
for(Int k=0;k<3;k++){
if(it!=hs.begin()) --it;
chmin(ans,calc(M,tmp+*it));
}
}
}
cout<<(Int)ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL<<45;
ll Sum[100],n,m,a,b,p,q;
ll calc(ll k){
ll A = 1,B = 1,res=p+q;
while(res>0&&res<=INF&&k--)A*=a,B*=b,res=p*A+q*B;
if(res<0) res = INF;
return min(INF,res);
}
ll ans = INF;
set<ll> used[101];
void dfs(ll pos,ll sum){
ans = min(ans,(ll)abs(m-sum));
if(m<sum||pos==-1||sum>INF||used[pos].count(sum)) return;
used[pos].insert(sum);
if(Sum[pos]+sum<m){ans=min(ans,m-(Sum[pos]+sum));return;}
dfs(pos-1,sum+calc(pos));
dfs(pos-1,sum);
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
Sum[0] = calc(0);
for(int i=1;i<60;i++)Sum[i]=min(INF,calc(i)+Sum[i-1]);
if(max(a,b)==1) {
ll s = abs(m - (m/(p+q))*(p+q));
ll t = abs(m - (m/(p+q))*(p+q) - (p+q));
if(m/(p+q)==n) t = INF;
if(m/(p+q)<=n) cout<<min(s,t)<<endl;
else cout<< m-(p+q)*n <<endl;
return 0;
}
dfs(min(n-1,50LL),0);
cout<<ans<<endl;
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_popcount
#define INF 1e18
#define mod 1000000007
ll n,m,a,b,p,q;
int main(){
cin>>n>>m>>a>>b>>p>>q;
ll res=m;
if(a==1&&b==1){
ll cnt=min(m/(p+q),n);
minch(res,m-cnt*(p+q));
cnt=min(cnt+1,n);
if(cnt*(p+q)-m>=0)minch(res,cnt*(p+q)-m);
cout<<res<<endl;
return 0;
}
ll crt1=p,crt2=q;
vector<ll> cs,cs1;
rep(k,n){
if(2*m<crt1+crt2)break;
cs.push_back(crt1+crt2);
if(2*m/a<crt1||2*m/b<crt2)break;
crt1*=a;
crt2*=b;
}
ll n1=cs.size()/2;
ll n2=cs.size()-n1;
rep(S,1<<n1){
ll sum=0;
rep(i,n1){
if((S>>i)&1)sum+=cs[i];
}
cs1.push_back(sum);
}
sort(all(cs1));
rep(S,1<<n2){
ll sum=0;
rep(i,n2){
if((S>>i)&1)sum+=cs[n1+i];
}
if(sum>=m){
minch(res,sum-m);
}else{
ll idx=lower_bound(all(cs1),m-sum)-cs1.begin();
if(idx<cs1.size()){
minch(res,sum+cs1[idx]-m);
}
if(idx>0){
minch(res,m-(sum+cs1[idx-1]));
}
}
}
cout<<res<<endl;
return 0;
}
|
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#define rep(i,n) for(int i = 0; i < n; ++i)
using namespace std;
using ll = long long;
using R = long double;
int main(void){
ll n,m,a,b,p,q;
cin >> n >> m >> a >> b >> p >> q;
if(a == 1 and b == 1){
ll ticket = p + q;
const ll used = min(n,m/ticket);
ll ans = abs(m - ticket * used);
if(used+1<=n) ans = min(ans,abs(m - ticket * (used+1)));
cout << ans << endl;
return 0;
}
vector<ll> ticket;
n = min(n,40LL);
rep(i,n){
ll cur = p * pow<ll>(a,i) + q * pow<ll>(b,i);
if(1.0 * p * pow<R>(a,i) + 1.0 * q * pow<R>(b,i) > 1e18) break;
ticket.push_back(cur);
if(cur > m) break;
}
n = ticket.size();
vector<ll> item[2];
const ll half[2] = {n/2,n-n/2};
const ll offset[2] = {0,n/2};
rep(k,2)rep(mask,1 << half[k]){
ll cur = 0LL;
rep(i,half[k]) if(mask & (1 << i)) cur += ticket[i+offset[k]];
item[k].push_back(cur);
}
ll ans = m;
sort(begin(item[1]),end(item[1]));
for(auto &it:item[0]){
const ll arg = m - it;
auto it2 = upper_bound(begin(item[1]),end(item[1]),arg);
if(it2 != end(item[1])) ans = min(ans, abs(m - it - *it2));
it2--;
ans = min(ans, m - it - *it2);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (int)(k); i < (int)(n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) a.begin(), a.end()
#define MS(m,v) memset(m,v,sizeof(m))
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
template<class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
ll pow(ll x, ll n)
{
ll res = 1;
while (n > 0)
{
if (n & 1) res = res * x;
x = x*x;
n >>= 1;
}
return res;
}
ll n, m, a, b, p, q;
ll calc(ll k)
{
return p * pow(a, k) + q * pow(b, k);
}
bool check(ld k)
{
return p * pow(a, k) + q * pow(b, k) <= pow(10, 12);
}
ll use(ll d)
{
ll loop = min(n + 1, 42ll);
ll res = n - 1;
REP(i, loop)
{
if (!check(i) || calc(i) > d)
{
res = i - 1;
break;
}
}
return res;
}
int main()
{
cin.sync_with_stdio(false); cout << fixed << setprecision(10);
cin >> n >> m >> a >> b >> p >> q;
ll ans = LLONG_MAX;
if (a == 1 && b == 1)
{
if (((ld)p + q) * n < (ld)m) ans = m - (p + q) * n;
else
{
ll t = m / (p + q);
ans = min(m - (p + q) * t, (p + q)*(t + 1) - m);
}
}
else if (a > 1 && b > 1)
{
set<int> st;
ll d = m;
int cnt = 0, mx = n;
int loop = min(n + 1, 41ll);
while (st.size() < loop)
{
ll t = use(d);
if (t + 1 < n && !st.count(t + 1) && d < calc(t + 1))
{
chmin(ans, calc(t + 1) - d);
}
if (t < 0) break;
ll tmp = min(n, t);
while (st.count(tmp) && tmp > 0) tmp--;
if (tmp == 0 && st.count(0)) break;
d -= calc(tmp);
st.insert(tmp);
chmin(ans, d);
}
chmin(ans, d);
}
else
{
int loop = min(n + 1, 41ll);
REP(i, loop)
{
set<int> st;
ll d = m;
int cnt = 0, mx = n;
while (st.size() < i)
{
ll t = use(d);
if (t < 0) break;
ll tmp = min(n - 1, t);
while (st.count(tmp) && tmp > 0) tmp--;
if (tmp == 0 && st.count(0)) break;
d -= calc(tmp);
st.insert(tmp);
}
if (st.size() == i - 1)
{
if (!st.count(0))
{
chmin(ans, calc(0) - d);
}
continue;
}
else if (st.size() != i) continue;
chmin(ans, d);
if (st.size() > 0)
{
int last = *st.begin();
if (last + 1 < n && !st.count(last + 1))
{
d = d + calc(last) - calc(last + 1);
chmin(ans, -d);
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
long long vals[50];
long long N;
long long M;
long long dfs(int id,int toTake,int taken,long long curVal,bool flg){
// printf("%d %d %d %lld\n",id,toTake,taken,curVal);
if(id==-1){
if(taken==toTake) return curVal;
else return -1;
}
if(toTake==taken){
return curVal;
}
long long nxtVal=curVal+vals[id];
// printf("nxt=%lld\n",nxtVal);
long long res=-1;
if(nxtVal>M){
res=dfs(id-1,toTake,taken,curVal,flg);
return res;
}
if(flg==false){
//not take
res=dfs(id-1,toTake,taken,curVal,true);
}
long long res2=dfs(id-1,toTake,taken+1,nxtVal,flg);
res=max(res,res2);
return res;
}
long long dfs2(int id,int toTake,int taken,long long curVal){
if(id==-1){
if(toTake!=taken) return -1;
if(curVal<M) return -1;
return curVal;
}
long long nxtVal=curVal+vals[id];
if(toTake==taken+id+1){
long long tmp=dfs2(id-1,toTake,taken+1,nxtVal);
return tmp;
}
long long notTake=curVal;
for(int i=1;i<=toTake-taken;i++){
notTake+=vals[id-i];
}
long long res;
if(notTake>=M){
res=dfs2(id-1,toTake,taken,curVal);
}else{
res=dfs2(id-1,toTake,taken+1,nxtVal);
}
return res;
}
long long mult(long long a,long long b,long long c){
long long x=c/a;
if(b>x) return -1;
long long res=a*b;
if(res>c) return -1;
return res;
}
int main(){
long long a,b,p,q;
scanf("%lld%lld%lld%lld%lld%lld",&N,&M,&a,&b,&p,&q);
if(a==1&&b==1){
long long x=p+q;
long long num=M/x;
num=min(num,N);
long long train=x*num;
long long ans=M-train;
if(num+1<=N){
train+=x;
ans=min(ans,train-M);
}
printf("%lld\n",ans);
return 0;
}
long long pa=1,pb=1;
int n=0;
for(int i=0;i<N;i++){
long long cur1=mult(pa,p,M*2);
long long cur2=mult(pb,q,M*2);
if(cur1==-1||cur2==-1) break;
long long cur=cur1+cur2;
if(cur>M*2) break;
vals[n++]=cur;
pa=mult(pa,a,M*2);
pb=mult(pb,b,M*2);
if(pa==-1||pb==-1) break;
}
if(n==0){
printf("%lld\n",M);
return 0;
}
// for(int i=0;i<n;i++){
// printf("%d %lld\n",i,vals[i]);
// }
N=n;
long long ans=M;
for(int i=1;i<=n;i++){
long long tmp=dfs(n-1,i,0,0,false);
// printf("%d %lld\n",i,tmp);
if(tmp==-1) continue;
ans=min(ans,M-tmp);
}
for(int i=1;i<=n;i++){
long long tmp=dfs2(n-1,i,0,0);
if(tmp==-1) continue;
ans=min(ans,tmp-M);
}
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using P=pair<ll,ll>;
#define MOD 1000000007ll
#define INF 1000000000ll
#define EPS 1e-10
#define FOR(i,n,m) for(ll i=n;i<(ll)m;i++)
#define REP(i,n) FOR(i,0,n)
#define DUMP(a) REP(d,a.size()){cout<<a[d];if(d!=a.size()-1)cout<<" ";else cout<<endl;}
#define ALL(v) v.begin(),v.end()
#define UNIQUE(v) sort(ALL(v));v.erase(unique(ALL(v)),v.end());
#define pb push_back
ll _pow(ll a, ll n) {
if(n == 0) return 1;
else {
ll res = 1;
ll buf = a;
while(n > 0) {
if(n % 2 == 1) {
res *= buf;
}
buf *= buf;
n /= 2;
}
return res;
}
}
void solve() {
ll tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
cin >> tmp1 >> tmp2 >> tmp3 >> tmp4 >> tmp5 >> tmp6;
__int128 n, m, a, b, p, q;
n = tmp1;
m = tmp2;
a = tmp3;
b = tmp4;
p = tmp5;
q = tmp6;
__int128 ans = m;
if(n == 1) {
ans = min(m, (__int128)abs((ll)((p + q) - m)));
cout << (ll)ans << endl;
return;
}
__int128 c = max(a, b);
if(c == 1) {
if((p + q) * n > m) {
ans = min(m - m / (p + q) * (p + q), (m / (p + q) + 1) * (p + q) - m);
} else ans = m - (p + q) * n;
} else if(c == 2 || c == 3) {
__int128 _n = 0;
if(c == 2) _n = min((__int128)41, n);
if(c == 3) _n = min((__int128)29, n);
ll div1 = _n / 2;
ll div2 = _n - div1;
vector<__int128> d1;
vector<__int128> d2;
REP(bit, (1ll << div1)) {
bitset<31> bi(bit);
__int128 sum = 0;
REP(i, div1) if(bi[i]) sum += p * _pow(a, i) + q * _pow(b, i);
d1.pb(sum);
}
REP(bit, (1ll << div2)) {
bitset<31> bi(bit);
__int128 sum = 0;
REP(i, div2) if(bi[i]) sum += p * _pow(a, div1 + i) + q * _pow(b, div1 + i);
d2.pb(sum);
}
sort(ALL(d1));
sort(ALL(d2));
REP(i, d1.size()) {
auto ite = upper_bound(ALL(d2), m - d1[i]);
if(ite != d2.end()) ans = min(ans, (d1[i] + *ite) - m);
if(ite == d2.begin()) continue;
ite--;
ans = min(ans, m - (d1[i] + *ite));
}
} else /* c >= 4 */ {
vector<__int128> num;
num.pb(0);
num.pb(p + q);
REP(i, min((__int128)23, n - 1)) {
if((__int128)1000000000007 / (ld)_pow(c, i) < c) break;
ll val = p * _pow(a, i + 1) + q * _pow(b, i + 1);
vector<__int128> nnum = num;
REP(j, num.size()) nnum.pb(num[j] + val);
num = nnum;
}
UNIQUE(num);
REP(i, num.size()) ans = min(ans, (__int128)abs((ll)(m - num[i])));
}
cout << (ll)ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include<iostream>
#include<set>
#include<cstdlib>
#include<vector>
#include<algorithm>
using namespace std;
long long n,m,a,b,p,q;
long long mul(long long a,long long b){
__int128 r=a;
r*=b;
if(r>1e18)throw 0;
return r;
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
if(a==1&&b==1){
long long c=m/(p+q);
cout<<min(m-min(n,c)*(p+q),llabs(min(n,c+1)*(p+q)-m))<<endl;
}else{
long long t[55]={};
t[0]=p+q;
long long ak=1,bk=1;
try{
for(int i=1;i<min(n,42ll);i++){
ak=mul(ak,a);
bk=mul(bk,b);
t[i]=mul(p,ak)+mul(q,bk);
}
}catch(...){
}
vector<long long> s(1<<21);
for(int i=0;i<1<<21;i++){
long long c=0;
for(int j=0;j<21;j++){
c+=(i>>j&1)*t[j+21];
}
s[i]=c;
}
sort(begin(s),end(s));
s.erase(unique(begin(s),end(s)),end(s));
long long ans=1e18;
for(int i=0;i<1<<21;i++){
long long c=0;
for(int j=0;j<21;j++){
c+=(i>>j&1)*t[j];
}
auto it=lower_bound(begin(s),end(s),m-c);
if(it!=s.end()){
ans=min(ans,llabs(m-*it-c));
}
if(it!=s.begin()){
it--;
ans=min(ans,llabs(m-*it-c));
}
}
cout<<ans<<endl;
}
}
|
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <string>
#include <algorithm>
#include <iostream>
#include <string>
#include <map>
#include <set>
#include <functional>
#include <iostream>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
ll labs(ll x){
if(x<0LL)return -x;
return x;
}
int zcnt(ll x){
int cnt=0;
while(x>0){
x/=10LL;
cnt++;
}
return cnt;
}
ll n,m,a,b,p,q;
ll num[51];
vector<ll> vec;
int main(void){
scanf("%lld%lld%lld%lld%lld%lld",&n,&m,&a,&b,&p,&q);
if(a==1LL && b==1LL){
ll dist=p+q;
ll cnt=m/dist;
printf("%lld\n",min(labs(m-min(cnt,n)*dist),labs(m-(min(cnt+1LL,n))*dist)));
}else{
ll v=0;
ll np=p,nq=q;
while(np+nq<=m){
num[v]=np+nq;
if(zcnt(np)+zcnt(a)>=zcnt(m)+4 || zcnt(nq)+zcnt(b)>=zcnt(m)+4)break;
np*=a;
nq*=b;
v++;
}
num[v]=np+nq;
v++;
ll res=m;
v=min(v,n);
if(v==0){
res=min(res,labs(m-p-q));
printf("%lld\n",res);
return 0;
}
int v2=(int)v/2;
for(int bit=0;bit<(1<<v2);bit++){
ll now=0;
for(int i=0;i<v2;i++){
if((bit>>i) & 1){
now+=num[i];
}
}
vec.push_back(now);
}
sort(vec.begin(),vec.end());
vec.erase(unique(vec.begin(),vec.end()),vec.end());
int v3=v-v2;
for(int bit=0;bit<(1<<v3);bit++){
ll now=0;
for(int i=0;i<v3;i++){
if((bit>>i) & 1){
now+=num[i+v2];
}
}
int l=lower_bound(vec.begin(),vec.end(),m-now)-vec.begin();
if(l<vec.size())res=min(res,labs(m-now-vec[l]));
if(l>0 || l==vec.size()){
res=min(res,labs(m-now-vec[l-1]));
}
}
printf("%lld\n",res);
}
return 0;
}
|
#include<cmath>
#include<cstdio>
#include<vector>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int main(){
ll n,m,a,b,p,q; scanf("%lld%lld%lld%lld%lld%lld",&n,&m,&a,&b,&p,&q);
ll ans=m;
if(a==1 && b==1){
ans=min(ans,llabs(n*(p+q)-m));
ll i=m/(p+q);
for(int j=-3;j<=3;j++) if(0<=i+j && i+j<=n) ans=min(ans,llabs((i+j)*(p+q)-m));
}
else{
int N;
ll num[40];
for(int k=0;;k++){
long double tmp=p*pow(a,k)+q*pow(b,k);
if(k==n || tmp>2e12){
N=k;
break;
}
num[k]=tmp;
}
if(N%2==1) num[N++]=0;
vector<ll> half1,half2;
rep(S,1<<N/2){
bool ok1=true,ok2=true;
ll sum1=0,sum2=0;
rep(i,N/2) if(S>>i&1) {
sum1+=num[i];
sum2+=num[i+N/2];
if(sum1>2e12) ok1=false;
if(sum2>2e12) ok2=false;
}
if(ok1) half1.push_back(sum1);
if(ok2) half2.push_back(sum2);
}
half1.push_back(0);
half2.push_back(0);
sort(half1.begin(),half1.end());
sort(half2.begin(),half2.end());
rep(i,half1.size()){
int j=lower_bound(half2.begin(),half2.end(),m-half1[i])-half2.begin();
if(j<half2.size()) ans=min(ans,llabs(half1[i]+half2[ j ]-m));
if(j>0) ans=min(ans,llabs(half1[i]+half2[j-1]-m));
}
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL<<53;
ll Sum[100];
ll n,m,a,b,p,q;
ll calc(ll k){
ll A = 1,B = 1;
ll res=p+q;
while(0<res&&res<=INF&&k--)A*=a,B*=b,res=p*A+q*B;
if(res<0||res>INF)res=INF;
return res;
}
ll ans = INF;
set<ll> used[101];
void dfs(ll pos,ll sum){
ans = min(ans,(ll)abs(m-sum));
if(m<sum||pos==-1||sum<0LL||sum>INF) return;
if(Sum[pos]+sum<m){ans=min(ans,m-(Sum[pos]+sum));return;}
if(used[pos].count(sum)) return ;
used[pos].insert(sum);
dfs(pos-1,sum+calc(pos));
dfs(pos-1,sum);
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
for(int i=0;i<60;i++) Sum[i] = INF;
Sum[0] = calc(0);
for(int i=1;i<60;i++)Sum[i]=min(INF,calc(i)+Sum[i-1]);
if(max(a,b)==1) {
ll s = abs(m - (m/(p+q))*(p+q));
ll t = abs(m - (m/(p+q))*(p+q) - (p+q));
if(m/(p+q)==n) t = INF;
if(m/(p+q)<=n) cout<<min(s,t)<<endl;
else cout<< m-(p+q)*n <<endl;
return 0;
}
dfs(min(n-1,50LL),0);
cout<<ans<<endl;
return 0;
}
|
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
using namespace std;
long long int atime(const long long int l, const long long int r) {
if (l > LLONG_MAX / r) {
return LLONG_MAX;
}
else {
return l*r;
}
}
long long int powint(long long int a, long long int b) {
if (!b)return 1;
else {
return atime(a, powint(a, b - 1));
}
}
long long int aplus(const long long int l, const long long int r) {
if (l > LLONG_MAX / 3 || r > LLONG_MAX)return LLONG_MAX;
else return l + r;
}
void getans(const vector<long long int>& sums,const vector<long long int>&tickets, const int now, long long int &ans,const long long int rest) {
if (now == tickets.size()) {
ans = min(ans, rest);
return;
}
if (ans < rest - sums[now])return;
if (rest >= tickets[now]) {
getans(sums, tickets, now + 1, ans, rest - tickets[now]);
}
else {
ans = min(ans, tickets[now] - rest);
}
getans(sums, tickets, now + 1, ans, rest);
}
int main() {
long long int N, M, A, B, P, Q;
cin >> N >> M >> A >> B >> P >> Q;
if (A > B) {
swap(A, B);
swap(P, Q);
}
assert(A <= B);
if (A == 1 && B == 1) {
long long int ticdis = P + Q;
if (atime(ticdis,N) <= M) {
cout << M - atime(ticdis, N) << endl;
}
else {
cout << min(ticdis-M%ticdis,M%ticdis) << endl;
}
}
else {
vector<long long int>tickets;
long long int ans = M;
for (int k = 0; k < N; ++k) {
long long int tic =aplus( atime(P, powint(A, k)), atime(Q, powint(B, k)));
if (tic > M) {
ans = min(ans, tic - M);
break;
}
else {
tickets.emplace_back(tic);
}
}
reverse(tickets.begin(), tickets.end());
vector<long long int>sums(tickets);
for (int i = sums.size()-1; i >0; --i) {
sums[i - 1] += sums[i];
}
getans(sums, tickets, 0, ans, M);
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,m,a,b,p,q,s[50],g;
vector<ll> v[2];
void dfs(int f,ll pos,ll ss,ll e){
if(pos==e){
v[f].push_back(ss);
return;
}
ll ns=s[pos]+ss;
dfs(f,pos+1,ss,e);
dfs(f,pos+1,ns,e);
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
if(b==1&&a==1){
if(m/(p+q)>=n)cout<<m-(p+q)*n<<endl;
else cout<<min(p+q-(m%(p+q)),m%(p+q))<<endl;
}
else{
for(ll i=0,x=p,y=q;i<n;i++,x*=a,y*=b){
ll ss=x+y;
s[g++]=ss;
if(ss>m)break;
}
v[0].push_back(0);
v[1].push_back(0);
v[1].push_back(1e16);
dfs(0,0,0,g/2);
dfs(1,g/2,0,g);
ll ans=m;
sort(v[1].begin(),v[1].end());
for(int i=0;i<v[0].size();i++){
int l=0,M,r=v[1].size();
while(l<r){
M=(l+r)/2;
if(v[0][i]+v[1][M]<=m)l=M+1;
else r=M;
}
ans=min(ans,m-v[0][i]-v[1][r-1]);
ans=min(ans,v[0][i]+v[1][r]-m);
}
cout<<ans<<endl;
}
return 0;
}
|
#include <cmath>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
long long N, M, A, B, P, Q;
cin >> N >> M >> A >> B >> P >> Q;
if (A == 1 && B == 1) {
long long d = M / (P + Q);
long long ret = (M > N * (P + Q) ? M - N * (P + Q) : N * (P + Q) - M);
if (d <= N) ret = min(ret, M - d * (P + Q));
if (d <= N - 1) ret = min(ret, (d + 1) * (P + Q) - M);
cout << ret << endl;
}
else {
double lim = log(2 * M) / max(log(A), log(B));
int rep = int(lim + 0.01);
long long mulA = 1, mulB = 1;
vector<long long> v;
for (int i = 0; i <= rep && i < N; ++i) {
v.push_back(P * mulA + Q * mulB);
mulA *= A;
mulB *= B;
}
int S = v.size();
int SL = S / 2, SR = S - S / 2;
vector<long long> vl(1 << SL), vr(1 << SR);
for (int i = 0; i < SL; ++i) {
for (int j = 1 << i; j < 2 << i; ++j) {
vl[j] = vl[j - (1 << i)] + v[i];
}
vector<long long> mem(2 << i);
merge(vl.begin(), vl.begin() + (1 << i), vl.begin() + (1 << i), vl.begin() + (2 << i), mem.begin());
copy(mem.begin(), mem.end(), vl.begin());
}
for (int i = 0; i < SR; ++i) {
for (int j = 1 << i; j < 2 << i; ++j) {
vr[j] = vr[j - (1 << i)] + v[i + SL];
}
vector<long long> mem(2 << i);
merge(vr.begin(), vr.begin() + (1 << i), vr.begin() + (1 << i), vr.begin() + (2 << i), mem.begin());
copy(mem.begin(), mem.end(), vr.begin());
}
int ptr = 1 << SR;
long long ans = M;
for (int i = 0; i < 1 << SL; ++i) {
while (ptr != 0 && vl[i] + vr[ptr - 1] > M) --ptr;
if (ptr != 0) ans = min(ans, M - vl[i] - vr[ptr - 1]);
if (ptr != (1 << SR)) ans = min(ans, vl[i] + vr[ptr] - M);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL<<53;
ll Sum[100];
ll n,m,a,b,p,q;
ll calc(ll k){
static ll used[101]={},mem[101]={};
if(used[k]++) return mem[k];
ll A = 1,B = 1;
ll &res =mem[k]=p+q;
while(0<res&&res<=INF&&k--)A*=a,B*=b,res=p*A+q*B;
if(res<0||res>INF)res=INF;
return res;
}
ll ans = INF;
set<ll> used[101];
void dfs(ll pos,ll sum){
if(sum<0LL||sum>INF) return;
ans = min(ans,(ll)abs(m-sum));
if(pos==-1)return;
if(Sum[pos]+sum<m){ans=min(ans,m-(Sum[pos]+sum));return;}
if(m<sum) return;
if(used[pos].count(sum)) return ;
used[pos].insert(sum);
ll r = calc(pos);
if(r<INF)dfs(pos-1,sum+r);
dfs(pos-1,sum);
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
for(int i=0;i<60;i++) Sum[i] = INF;
Sum[0] = calc(0);
for(int i=1;i<60;i++)Sum[i]=min(INF,calc(i)+Sum[i-1]);
if(max(a,b)==1) {
ll s = abs(m - (m/(p+q))*(p+q));
ll t = abs(m - (m/(p+q))*(p+q) - (p+q));
if(m/(p+q)==n) t = INF;
if(m/(p+q)<=n) cout<<min(s,t)<<endl;
else cout<< m-(p+q)*n <<endl;
return 0;
}
dfs(min(n-1,50LL),0);
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL<<45;
ll Sum[100];
ll n,m,a,b,p,q;
ll calc(ll k){
ll A = 1,B = 1,res=p+q;
while(res>0&&res<=INF&&k--)A*=a,B*=b,res=p*A+q*B;
if(res<0) res = INF;
return min(INF,res);
}
ll ans = INF;
set<ll> used[101];
void dfs(ll pos,ll sum){
ans = min(ans,(ll)abs(m-sum));
if(m<sum||pos==-1||sum>INF||used[pos].count(sum)) return;
if(Sum[pos]+sum<m){ans=min(ans,m-(Sum[pos]+sum));return;}
used[pos].insert(sum);
dfs(pos-1,sum+calc(pos));
dfs(pos-1,sum);
}
int main(){
cin>>n>>m>>a>>b>>p>>q;
Sum[0] = calc(0);
for(int i=1;i<60;i++)Sum[i]=min(INF,calc(i)+Sum[i-1]);
if(max(a,b)==1) {
ll s = abs(m - (m/(p+q))*(p+q));
ll t = abs(m - (m/(p+q))*(p+q) - (p+q));
if(m/(p+q)==n) t = INF;
if(m/(p+q)<=n) cout<<min(s,t)<<endl;
else cout<< m-(p+q)*n <<endl;
return 0;
}
dfs(min(n-1,50LL),0);
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <queue>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
typedef long long ll;
using namespace std;
const ll inf = 1ll << 60;
ll mult(ll a, ll b){
if(inf / a < b) throw 0;
return a * b;
}
int main(){
ll n, m, a, b, p, q;
cin >> n >> m >> a >> b >> p >> q;
if(a == 1 && b == 1){
ll tmp = min(n + 1, m / (p + q));
ll ans = inf;
for(ll t = max(0ll, tmp - 2); t < min(n + 1, tmp + 2); t++){
ll tt = t * (p + q);
ans = min(ans, std::abs(m - tt));
}
cout << ans << endl;
return 0;
}
if(n > 40) n = 40;
vector<ll> v;
ll aa = 1;
ll bb = 1;
try{
REP(i,n){
ll val = mult(p, aa) + mult(q, bb);
if(val <= m + m) v.push_back(val);
else break;
aa = mult(aa, a);
bb = mult(bb, b);
}
}catch(int n){}
vector<ll> as;
vector<ll> bs;
n = v.size();
if(n == 1){
cout << min(m, std::abs(m - v[0])) << endl;
return 0;
}
REP(i,1<<(n/2)){
ll tmp = 0;
REP(j,n/2) if(i & (1 << j)) tmp += v[j];
as.push_back(tmp);
}
REP(i,1<<(n/2 + n%2)){
ll tmp = 0;
REP(j,n/2 + n%2) if(i & (1 << j))
tmp += v[j + n / 2];
bs.push_back(tmp);
}
sort(as.begin(), as.end());
sort(bs.rbegin(), bs.rend());
size_t ai = 0, an = as.size() - 1;
size_t bi = 0, bn = bs.size() - 1;
ll ans = m;
while(ai < an || bi < an){
ll tmp = as[ai] + bs[bi];
ans = min(ans, std::abs(m - tmp));
if(tmp > m){
if(bi != bn) bi++;
else ai++;
}else{
if(ai != an) ai++;
else bi++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
#define INF 2e+12
using namespace std;
signed main(){
int n,m,a,b,p,q,mi;
vector<int> vec,num;
cin >> n >> m >> a >> b >> p >> q;
mi = m;
if(a == 1 && b == 1){
if(p + q >= (m + n - 1) / n) cout << min(m % (p + q),p + q - m % (p + q)) << endl;
else cout << m - (p + q) * n << endl;
return 0;
}
int ta = p,tb = q;
for(int i = 0;i < n;i++){
if(ta + tb > INF) break;
vec.push_back(ta + tb);
if(ta > (INF + a - 1) / a || tb > (INF + b - 1) / b) break;
ta *= a;
tb *= b;
}
n = vec.size();
for(int i = 0;i < (1 << (n / 2));i++){
int sum = 0;
for(int j = 0;j < n / 2;j++){
if((i >> j) & 1) sum += vec[j];
}
num.push_back(sum);
}
sort(num.begin(),num.end());
for(int i = 0;i < (1 << ((n + 1) / 2));i++){
int sum = 0;
for(int j = 0;j < (n + 1) / 2;j++){
if((i >> j) & 1) sum += vec[j + n / 2];
}
int ind = upper_bound(num.begin(),num.end(),m - sum) - num.begin() - 1;
if(ind >= 0) mi = min(mi,m - sum - num[ind]);
if(ind + 1 < n) mi = min(mi,-(m - sum - num[ind + 1]));
}
cout << mi << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <utility>
#include <queue>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
#define MP make_pair
#define PB push_back
#define inf 1000000007
int main(){
ll n,m,a,b,p,q;
cin >> n >> m >> a >> b >> p >> q;
if(a==1&&b==1){
ll ans = m;
ll x = p+q;
ll y = m/x;
if(y>=n){
ans = min(ans,m-x*n);
cout << ans << endl;
}else{
ans = min(ans,m-(x*y));
ans = min(ans,x-ans);
cout << ans << endl;
}
return 0;
}
vector<ll> r1,r2;
r1.push_back(1);
r2.push_back(1);
if(p+q >= m){
cout << min(m,p+q-m) << endl;
return 0;
}
for(int i=1;i<n;i++){
r1.PB(r1[i-1]*a);
r2.PB(r2[i-1]*b);
if(p*r1[i]+q*r2[i]>=m){
n=i+1;
}
}
ll ans=m;
if(p*r1[n-1]+q*r2[n-1]>=m){
ans = min(ans,p*r1[n-1]+q*r2[n-1]-m);
n--;
}
vector<ll> s1,s2,t1,t2;
const ll mae = n/2;
const ll usi = n - mae;
for(int i=0;i<n/2;i++){
s1.push_back(p*r1[i]+q*r2[i]);
}
for(int i=n/2;i<n;i++){
s2.push_back(p*r1[i]+q*r2[i]);
}
/*for(int i=0;i<mae;i++){
cout << s1[i] << endl;
}
cout << endl;
for(int i=0;i<usi;i++){
cout << s2[i] << endl;
}*/
for(ll i=0;i<(1LL<<(mae));i++){
ll s = 0;
for(ll j=0;j<mae;j++){
if(i&(1LL<<j)){
s += s1[j];
}
}
t1.push_back(s);
}
for(ll i=0;i<(1LL<<(usi));i++){
ll s = 0;
for(ll j=0;j<usi;j++){
if(i&(1LL<<j)){
s += s2[j];
}
}
t2.push_back(s);
}
sort(t1.begin(),t1.end());
sort(t2.begin(),t2.end());
/*for(int i=0;i<t1.size();i++){
cout << t1[i] << endl;
}
for(int i=0;i<t2.size();i++){
cout << t2[i] << endl;
}*/
for(int i=0;i<t1.size();i++){
int k = lower_bound(t2.begin(),t2.end(),m-t1[i])-t2.begin()-1;
ans = min(ans,abs(m-t1[i]-t2[k]));
if(k+1<t2.size()){
ans = min(ans,abs(m-t1[i]-t2[k+1]));
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <fstream>
#include <cassert>
#include <typeinfo>
#include <vector>
#include <stack>
#include <cmath>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <iomanip>
#include <cctype>
#include <random>
#include <complex>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<29;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-7;
const ll mod=1e9+7;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll n,m,a,b,p,q;
int main(){
cin>>n>>m>>a>>b>>p>>q;
if(a==1&&b==1){
ll x=p+q,tmp=min(m/x,n),res=m-x*tmp;
if(tmp!=n) res=min(res,x*(tmp+1)-m);
cout<<res<<endl;
return 0;
}
vl x;
bool B=0;
int I=0;
do{
if(p+q>m) B=1;
x.push_back(p+q);
if(INF/p>a) p*=a;
else break;
if(INF/q>b) q*=b;
else break;
I++;
}while(I<n&&!B);
int S=x.size(),S2=S/2,T=S-S2;
vl c(1<<S2);
for(int i=0;i<1<<S2;i++){
for(int j=0;j<S2;j++) if(i&1<<j) c[i]+=x[j];
}
sort(c.begin(),c.end());
ll res=INF;
for(int i=0;i<1<<T;i++){
ll tmp=0;
for(int j=0;j<T;j++) if(i&1<<j) tmp+=x[S2+j];
auto it=lower_bound(c.begin(),c.end(),m-tmp);
if(it!=c.end()) res=min(res,abs(m-tmp-*it));
if(it!=c.begin()) res=min(res,abs(m-tmp-*(it-1)));
}
cout<<res<<endl;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define INF 1<<30
#define LINF 1LL<<60
/*
<url:http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2239>
?????????============================================================
????????????????????????????????±?????????n ????????£?????????. ?????±????????????????????????0 ??????n ??? 1 ?????§???????????????????????????,
k ???????????±?????????????????¨, p???a^k + q???b^k ?§????????????¨?????§??????.
??????????????????????§???????m ?§???????????§???????????????????????£??????????????????????????????????,???????????????????????¢??????????????????.
?§????????????????????????§??????.
?????±?????????????????????????????§???????????¨???????????¨????????¨???, ????????????????°?????§???????????????§??????????????????.
1 ??? n, m, a, b, p, q ??? 10^12 (??´??°)
=================================================================
?§£??¬=============================================================
================================================================
*/
ll powmod(ll a, ll b) { ll res = 1; assert(b >= 0); for (;b;b >>= 1) { if (b & 1)res = res*a;a = a*a; }return res; }
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
ll n, m, a, b, p, q; cin >> n >> m >> a >> b >> p >> q;
ll res = m;
if (a == 1 && b == 1) {
ll k = m / (p + q);
res = min({ m,abs(m - min(k,n)*(p + q)),abs(min((k + 1),n)*(p + q) - m )});
}else {
ll N = min(40LL, n);
vector<ll> dist;
for (int i = 0; i < N;i++) {
ll d = p * powmod(a, i) + q*powmod(b, i);
if (d > 2 * m)break;
dist.push_back(d);
}
int n1 = (int)dist.size() / 2;
int n2 = (int)dist.size() - n1;
vector<ll> L;
for (int i = 0; i < (1 << n1);i++) {
ll T = 0;
for (int j = 0; j < n1;j++) {
if ((i >> j) & 1) {
T += dist[j];
}
}
if (T > 2 * m)continue;
L.push_back(T);
}
sort(L.begin(), L.end());
for (int i = 0; i < (1 << n2);i++) {
ll T = 0;
for (int j = 0; j < n2;j++) {
if ((i >> j) & 1) {
T += dist[n1 + j];
}
}
if (T > 2 * m)continue;
auto it = lower_bound(L.begin(), L.end(), m - T);
if(it != L.end())res = min(res, abs(m - T - *it));
if (it != L.begin()) res = min(res, abs(m - T - *(it - 1)));
}
}
cout << res << endl;
return 0;
}
|
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <utility>
#define show(x) cerr << #x << " = " << x << endl
using namespace std;
using ld = long double;
using ll = long long;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (const auto& e : v) {
os << e << ",";
}
os << "] ";
os << "size = " << v.size() << endl;
return os;
}
int main()
{
ll n, m, a, b, p, q;
cin >> n >> m >> a >> b >> p >> q;
if (p + q > m) {
cout << min(m, p + q - m) << endl;
} else if (a == 1 and b == 1) {
ll nearest = m / (p + q);
if (m - (p + q) * nearest > (p + q) * (nearest + 1) - m) {
nearest++;
}
if (nearest > n) {
cout << m - (p + q) * n << endl;
} else {
cout << (p + q) * nearest - m << endl;
}
} else {
ll k = 0;
ll A = 1;
ll B = 1;
vector<ll> value;
for (; p * A + q * B <= m and k < n; k++) {
value.push_back(p * A + q * B);
A *= a;
B *= b;
}
n = k;
const ll former = n / 2;
const ll latter = n - former;
const ll fmax = 1 << former;
const ll lmax = 1 << latter;
vector<ll> fsum(fmax, 0LL);
for (ll i = 0; i < fmax; i++) {
for (ll j = 0; j < former; j++) {
if (i & (1LL << j)) {
fsum[i] = fsum[i - (1LL << j)] + value[j];
break;
}
}
}
vector<ll> lsum(lmax, 0LL);
for (ll i = 0; i < lmax; i++) {
for (ll j = 0; j < latter; j++) {
if (i & (1LL << j)) {
lsum[i] = lsum[i - (1LL << j)] + value[former + j];
break;
}
}
}
sort(lsum.begin(), lsum.end());
constexpr ll INF = 1LL << 60;
ll error = INF;
for (ll f : fsum) {
const ll res = m - f;
if (res <= 0) {
error = min(error, -res);
} else {
auto it = lower_bound(lsum.begin(), lsum.end(), res);
if (it != lsum.end()) {
error = min(error, abs(res - (*it)));
}
it--;
error = min(error, abs(res - (*it)));
}
}
cout << error << endl;
}
return 0;
}
|
#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<complex>
#include<tuple>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
typedef pair<double,ll> pdl;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;
__int128 parse(string &s) {
__int128 ret = 0;
for (int i = 0; i < s.length(); i++)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t tmp = value < 0 ? -value : value;
char buffer[128];
char *d = std::end(buffer);
do {
--d;
*d = "0123456789"[tmp % 10];
tmp /= 10;
} while (tmp != 0);
if (value < 0) {
--d;
*d = '-';
}
int len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
std::istream &operator>>(std::istream &dest, __int128 &value) {
string s;
cin>>s;
value=parse(s);
return dest;
}
typedef __int128 Int;
int main(){
Int n,m,a,b,p,q;
cin>>n>>m>>a>>b>>p>>q;
if(a==1 && b==1){
Int sum=p+q;
Int M=min(m/sum,n);
Int ans=m-M*sum;
Int k=m-(M+1)*sum;
if(k<0){k*=-1;}
if(M!=n){ans=min(ans,k);}
cout<<ans<<endl;
}
else{
vector<ll> A;
Int s=1,t=1;
int i;
for(i=0;i<n && s*p+t*q<=m;i++,s*=a,t*=b){
A.push_back(s*p+t*q);
}
if(i<n && s*p+t*q<=m*2){A.push_back(s*p+t*q);}
vector<ll> B;
while(A.size()>B.size()){B.push_back(A.back()); A.pop_back();}
vector<ll> F;
for(ll i=0;i<(1LL<<A.size());i++){
ll sum=0;
for(int t=0;t<A.size();t++){
if(i>>t&1){sum+=A[t];}
}
F.push_back(sum);
}
ll ans=m;
sort(F.begin(),F.end());
for(ll i=0;i<(1LL<<B.size());i++){
ll sum=0;
for(int t=0;t<B.size();t++){
if(i>>t&1){sum+=B[t];}
}
ll rem=m-sum;
ll idx=lower_bound(F.begin(),F.end(),rem)-F.begin();
if(idx!=F.size()){ans=min(ans,abs(F[idx]-rem));}
if(idx!=0){ans=min(ans,abs(rem-F[idx-1]));}
}
cout<<ans<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
bool ch(int a,int b){
int x=1000000000000000LL;
x/=a;
x/=b;
return x==0;
}
signed main(){
int n,m,a,b,p,q;
cin>>n>>m>>a>>b>>p>>q;
if(a==1&&b==1){
//cout<<m%(p+q)<<endl;
if(ch(n,p+q)) cout<<min(m%(p+q),(p+q)-m%(p+q))<<endl;
else{
int t=n*(p+q);
if(m>=t) cout<<m-t<<endl;
else cout<<min(m%(p+q),(p+q)-m%(p+q))<<endl;
}
return 0;
}
int ans=m;
int ta=1,tb=1;
vector<int> v;
for(int i=0;i<n;i++){
if(ch(p,ta)) break;
if(ch(q,tb)) break;
int t=p*ta+q*tb;
//cout<<t<<endl;
if(t<=m) v.push_back(t);
else{
ans=min(ans,t-m);
break;
}
if(ch(ta,a)) break;
if(ch(tb,b)) break;
ta*=a;tb*=b;
}
int x=v.size();
int y=x/2;
set<int> s;
for(int i=0;i<(1<<y);i++){
int t=0;
for(int j=0;j<y;j++) if((i>>j)&1) t+=v[j];
if(t>m){
ans=min(ans,t-m);
continue;
}
//cout<<t<<endl;
s.insert(-t);
ans=min(ans,m-t);
}
for(int i=0;i<(1<<(x-y));i++){
int t=0;
for(int j=0;j<(x-y);j++) if((i>>j)&1) t+=v[y+j];
if(t>m){
ans=min(ans,t-m);
continue;
}
//cout<<t<<endl;
ans=min(ans,m-t);
int u=t-m;
int k=*s.lower_bound(u);
ans=min(ans,m-(t-k));
}
s.clear();
for(int i=0;i<(1<<y);i++){
int t=0;
for(int j=0;j<y;j++) if((i>>j)&1) t+=v[j];
if(t>m){
ans=min(ans,t-m);
continue;
}
//cout<<t<<endl;
s.insert(t);
ans=min(ans,m-t);
}
int inf=m*2;
s.insert(inf);
for(int i=0;i<(1<<(x-y));i++){
int t=0;
for(int j=0;j<(x-y);j++) if((i>>j)&1) t+=v[y+j];
if(t>m){
ans=min(ans,t-m);
continue;
}
//cout<<t<<endl;
ans=min(ans,m-t);
int v=m-t;
int l=*s.lower_bound(v);
if(l!=inf) ans=min(ans,(t+l)-m);
}
//assert(ans>=0);
cout<<ans<<endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it,X) for(__typeof((X).begin()) it=(X).begin();it!=(X).end();it++)
#define ite iterator
#define mp make_pair
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define pb push_back
#define sec second
#define sz(x) ((int)(x).size())
using namespace std;
struct timer{
time_t start;
timer(){start=clock();}
~timer(){cerr<<1.*(clock()-start)/CLOCKS_PER_SEC<<" secs"<<endl;}
};
typedef istringstream iss;
typedef long long ll;
typedef pair<int,int> pi;
typedef stringstream sst;
typedef vector<int> vi;
ll n,m,a,b,p,q;
vector<ll> v;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
cin>>n>>m>>a>>b>>p>>q;
if(a==1 && b==1){
ll t=p+q;
if(n < (m+t-1)/t){
cout<<m-t*n<<endl;
}else{
cout<<min(m%t,t-m%t)<<endl;
}
return 0;
}
vector<ll> v;
ll pa=p,qb=q;
double pa_=p,qb_=q;
rep(i,n){
if(pa_+qb_>3*m)break;
if(pa+qb>2*m)break;
v.pb(pa+qb);
pa*=a,qb*=b;
pa_*=a,qb_*=b;
}
//rep(i,sz(v))cout<<v[i]<<" ";cout<<endl;
vector<ll> v0,v1,sum;
int N=sz(v)/2;
rep(i,sz(v)){
if(i<N)v0.pb(v[i]);
else v1.pb(v[i]);
}
rep(mask,1<<sz(v1)){
ll s=0;
rep(i,sz(v1))if(mask>>i&1){
s+=v1[i];
}
sum.pb(s);
}
sort(sum.begin(),sum.end());
ll ans=m;
rep(mask,1<<sz(v0)){
ll s=0;
rep(i,sz(v0))if(mask>>i&1){
s+=v0[i];
}
if(s>=m){
ans=min(ans,s-m);
}else{
ll rest=m-s;
vector<ll>::ite it=lower_bound(sum.begin(),sum.end(),rest);
if(it!=sum.end())ans=min(ans,*it-rest);
it--;
ans=min(ans,rest-*it);
}
}
cout<<ans<<endl;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
long long n, m, a, b, p, q, minx, d, s, B;
long long x[10000], y[10000], c[10000];
long long rem;
int main() {
cin >> n >> m >> a >> b >> p >> q;
x[0] = 1; y[0] = 1;
s = min((long long)10000, n);
if (a >= 1000000000 && b >= 1000000000) {
if (p >= 1000000000 && q >= 1000000000) {
cout << min(m, abs(m - p - q)) << endl;
}
else {
cout << min(m, min(abs(m - p - q), min(abs(m - a * p - b * q), abs(m - a * p - b * q - p - q)))) << endl;
}
return 0;
}
for (int i = 1; i < s; i++) {
x[i] = x[i - 1] * a;
if (x[i] > m) { break; }
}
for (int i = 1; i < s; i++) {
y[i] = y[i - 1] * b;
if (x[i] > m) { break; }
}
if (a == 1 && b == 1) {
if (n >= 1000001 && (p + q) >= 1000001) { goto F; }
if (m <= n * (p + q)) {
F:;
B = m % (p + q);
if (B > (p + q) / 2) {
B = (p + q) - B;
}
cout << B << endl;
}
else {
cout << m - (long long)(n * (p + q)) << endl;
}
return 0;
}
for (int i = 0; i < s; i++) {
c[i] = p*x[i] + q*y[i];
if (c[i] > m) {
d = i;
minx = c[i] - m;
goto E;
}
}
minx = m;
d = s;
E:;
rem = m - c[d - 1];
minx = min(minx, abs(rem));
for (int i = d - 2; i >= 0; i--) {
minx = min(minx, (long long)abs(rem - c[i]));
if (rem >= c[i]) {
rem -= c[i];
}
}
cout << minx << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int64;
int main()
{
int64 N, M, A, B, P, Q;
cin >> N >> M >> A >> B >> P >> Q;
if(A == 1 && B == 1) {
int64 T = P + Q;
if(N < (M + T - 1) / T) {
cout << M - T * N << endl;
} else {
cout << min(M % T, T - M % T) << endl;
}
} else {
int64 PA = P, QB = Q;
vector< int64 > vs;
for(int i = 0; i < min(42LL, N); i++) {
vs.push_back(PA + QB);
if((double) PA * A + QB * B > 1e18) break;
PA *= A;
QB *= B;
}
int mid = vs.size() / 2;
int rest = vs.size() - mid;
vector< int64 > ss(1 << mid, 0);
for(int i = 0; i < (1 << mid); i++) {
for(int j = 0; j < mid; j++) {
if((i >> j) & 1) ss[i] += vs[j];
}
}
sort(begin(ss), end(ss));
ss.erase(unique(begin(ss), end(ss)), end(ss));
int64 ret = 1LL << 60;
for(int i = 0; i < (1 << rest); i++) {
int64 now = 0;
for(int j = 0; j < rest; j++) {
if((i >> j) & 1) now += vs[mid + j];
}
auto ptr = lower_bound(begin(ss), end(ss), M - now);
if(ptr != ss.end()) ret = min(ret, llabs(M - now - *ptr));
if(ptr != ss.begin()) ret = min(ret, llabs(M - now - *--ptr));
}
cout << ret << endl;
}
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>
#define repeat(i, n) for (int i = 0; (i) < int(n); ++(i))
#define repeat_from(i, m, n) for (int i = (m); (i) < int(n); ++(i))
#define whole(f, x, ...) ([&](decltype((x)) whole) { return (f)(begin(whole), end(whole), ## __VA_ARGS__); })(x)
using ll = long long;
using namespace std;
template <class T> inline void setmin(T & a, T const & b) { a = min(a, b); }
ll solve(ll n, ll m, ll a, ll b, ll p, ll q) {
if (a == 1 and b == 1) {
ll delta = p + q;
ll result = m;
setmin(result, abs(m - min(n, m / delta) * delta));
setmin(result, abs(m - min(n, (m + delta - 1) / delta) * delta));
return result;
}
vector<ll> tickets;
for (ll k = 0; k < n; ++ k) {
double ticket = p * pow(a, k) + q * pow(b, k);
if (2 * m + 3 < ticket) break;
tickets.push_back(ticket);
}
if (tickets.empty()) {
return m;
} else if (tickets.size() == 1) {
return min(m, abs(m - tickets[0]));
}
auto generate = [&](int l, int r) {
vector<ll> acc;
acc.push_back(0);
repeat_from (k, l, r) {
ll ticket = tickets[k];
int prev_size = acc.size();
repeat (i, prev_size) {
acc.push_back(acc[i] + ticket);
}
whole(sort, acc);
acc.erase(whole(unique, acc), acc.end());
}
return acc;
};
vector<ll> lower = generate(0, tickets.size() / 2);
vector<ll> upper = generate(tickets.size() / 2, tickets.size());
ll result = m;
for (ll x : lower) {
int i = whole(lower_bound, upper, m - x) - upper.begin();
repeat_from (j, max(0, i - 3), min<int>(upper.size(), i + 3)) {
ll y = upper[j];
setmin(result, abs(m - (x + y)));
}
}
return result;
}
int main() {
ll n, m, a, b, p, q; scanf("%lld%lld%lld%lld%lld%lld", &n, &m, &a, &b, &p, &q);
ll result = solve(n, m, a, b, p, q);
printf("%lld\n", result);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
const double EPS = 1e-10;
const ll INF = 100000000;
const ll MOD = 1000000007;
ll n, m, a, b, p, q;
ll X[41];
ll nX;
ll x[(1<<21)], y[(1<<21)];
ll nx, ny;
int main() {
cin >> n >> m >> a >> b >> p >> q;
if (a == 1 && b == 1) {
if ((p+q) <= m/n) cout << m - n*(p+q) << endl;
else cout << min(m % (p+q), p+q - m%(p+q)) << endl;
return 0;
}
{
ll pre = p, pos = q;
rep(i,n) {
X[i] = pre + pos;
nX++;
if (pre + pos >= m) {
break;
}
pre *= a; pos *= b;
}
}
nx = nX/2;
ny = nX - nx;
rep(i,(1<<nx)) {
ll pos = 0;
rep(j,nx) {
if (i&(1<<j)) pos += X[j];
if (pos > m) break;
}
x[i] = pos;
}
rep(i,(1<<ny)) {
ll pos = 0;
rep(j,ny) {
if (i&(1<<j)) pos += X[nx+j];
if (pos > m) break;
}
y[i] = pos;
}
sort(x, x+(1<<nx));
sort(y, y+(1<<ny));
ll ans = INF*INF;
rep(i,(1<<nx)) {
int p = lower_bound(y, y+(1<<ny), m-x[i]) - y;
ans = min(ans, abs(y[p]+x[i]-m));
if (p != 0) ans = min(ans, abs(y[p-1]+x[i]-m));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll inf = 1e18;
ll mul(ll a, ll b) {
if(a > inf / b) return inf;
return a * b;
}
ll mypow(ll x, ll n) {
ll res = 1;
while(n > 0) {
if(n & 1) {
res = mul(res, x);
}
x = mul(x, x);
n >>= 1;
}
return res;
}
ll solve(ll n, ll m, ll a, ll b, ll p, ll q) {
if(a == 1 && b == 1) {
const ll t = (p + q);
ll sum = mul(t, n);
if(sum <= m) return m - sum;
return min(m % t, t - m % t);
}
vector<ll> s1, s2, t1, t2;
for(int i = 0; i < min(n, 40LL); ++i) {
(i & 1 ? s1 : s2).push_back(mul(mypow(a, i), p) + mul(mypow(b, i), q));
}
const int sz1 = s1.size(), sz2 = s2.size();
for(int S = 0; S < (1 << sz1); ++S) {
ll sum = 0;
for(int i = 0; i < sz1; ++i) {
if(S & (1 << i)) sum = min(inf, sum + s1[i]);
}
t1.push_back(sum);
}
for(int S = 0; S < (1 << sz2); ++S) {
ll sum = 0;
for(int i = 0; i < sz2; ++i) {
if(S & (1 << i)) sum = min(inf, sum + s2[i]);
}
t2.push_back(sum);
}
sort(begin(t1), end(t1));
sort(begin(t2), end(t2));
ll res = m;
const int tsz2 = t2.size();
for(auto x1 : t1) {
const ll target = m - x1;
const int idx = lower_bound(begin(t2), end(t2), target) - begin(t2);
for(int i = idx - 1; i <= idx + 1; ++i) {
if(i < 0 || tsz2 <= i) continue;
res = min(res, abs(m - (x1 + t2[i])));
}
}
return res;
}
int main() {
ll n, m, a, b, p, q;
cin >> n >> m >> a >> b >> p >> q;
cout << solve(n, m, a, b, p, q) << endl;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
#include <functional>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define rep1(i,n) for(int i=1;i<=(n);++i)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
typedef long long ll;
ll inf=1e14;
int main(){
ll n,m,a,b,p,q;
cin>>n>>m>>a>>b>>p>>q;
if(a>b) swap(a,b),swap(p,q);
ll ans=m;
if(b==1){
ll k=p+q;
ll d=min(n,m/k);
ans=m-k*d;
if(d!=n) ans=min(ans,(d+1)*k-m);
}else if(a==1){
ll bq[45]={},sum[46]={};
bq[0]=q;
sum[1]=q;
ll id=0;
for(;id<n-1;id++){
if(bq[id]>inf/b) break;
bq[id+1]=bq[id]*b;
sum[id+2]=sum[id+1]+bq[id+1];
}
/* show(id);
rep(i,id+1){
show(bq[i]);
show(sum[i]);
}*/
//can use 0~id
ll id_c=id;
for(ll k=1;k<=min(n,id_c+1);k++){
if(bq[k-1]==0) break;
// show(k);
ll left=m-p*k;
ll now=0;
id=id_c;
int use=0;
for(;id>=0;id--){
if(now+bq[id]>left){
if(k-use-1>=0&&k-use-1<=id) ans=min(ans,now+bq[id]+sum[k-use-1]-left);
}else{
now+=bq[id];
use++;
if(use==k){
ans=min(ans,left-now);
break;
}
}
}
}
}else{
ll id=0;
ll l=p,r=q;
ll num[45]={};
for(;id<n;id++){
num[id]=l+r;
if(l>inf/a) break;
if(r>inf/b) break;
l*=a;
r*=b;
}
if(id==n) id--;
//can use 0~id
// show(id);
// rep(i,id+1){
// show(num[i]);
// }
ll now=0;
for(;id>=0;id--){
if(now+num[id]>m){
ans=min(ans,now+num[id]-m);
}else{
ans=min(ans,m-(now+num[id]));
now+=num[id];
}
}
}
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=__int128;
using ll2=long long;
const ll INF=1e15;
ll powi(ll x,ll k){
ll res=1;
while(k){
if(k&1) res*=x;
if(res>INF) return INF;
x*=x;
k>>=1;
}
return res;
}
int main(){
ll2 nn,mm,aa,bb,pp,qq;
cin>>nn>>mm>>aa>>bb>>pp>>qq;
ll n=nn,m=mm,a=aa,b=bb,p=pp,q=qq;
if(a>=2 || b>=2){
int tn=min(n,ll(41));
int half=min(tn/2,20);
vector<ll> vec(1<<half);
for(int i=0;i<(1<<half);i++){
ll val=0;
for(int j=0;j<half;j++){
if((i>>j)&1){
val+=p*powi(a,j)+q*powi(b,j);
}
if(val>=INF){
break;
}
}
vec[i]=val;
}
int rest=tn-half;
vector<ll> s(1<<rest);
for(int i=0;i<(1<<rest);i++){
ll val=0;
for(int j=0;j<rest;j++){
if((i>>j)&1){
val+=p*powi(a,half+j)+q*powi(b,half+j);
}
if(val>=INF){
break;
}
}
s[i]=val;
}
sort(s.begin(),s.end());
ll2 res=m;
for(int i=0;i<vec.size();i++){
auto it=lower_bound(s.begin(),s.end(),m-vec[i]);
if(it!=s.end()){
res=min(res,abs(ll2(m-vec[i]-*it)));
}
if(it!=s.begin()){
it--;
res=min(res,abs(ll2(m-vec[i]-*it)));
}
}
cout<<res<<endl;
}
else{
if((p+q)*n>=m){
cout<<ll2(min(m%(p+q),(p+q)-m%(p+q)))<<endl;
}
else{
cout<<ll2(m-(p+q)*n)<<endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define rrep(i,n) for(int i=(int)(n)-1;i>=0;--i)
#define srep(i,s,t) for(int i=(int)(s);i<(int)(t);++i)
#define each(a,b) for(auto (a): (b))
#define all(v) (v).begin(),(v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)),v.erase(unique(all(v)),v.end())
#define cmx(x,y) x=max(x,y)
#define cmn(x,y) x=min(x,y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout<<#x<<" = "<<(x)<<endl
#define spair(p) cout<<#p<<": "<<p.fi<<" "<<p.se<<endl
#define svec(v) cout<<#v<<":";rep(kbrni,v.size())cout<<" "<<v[kbrni];cout<<endl
#define sset(s) cout<<#s<<":";each(kbrni,s)cout<<" "<<kbrni;cout<<endl
#define smap(m) cout<<#m<<":";each(kbrni,m)cout<<" {"<<kbrni.first<<":"<<kbrni.second<<"}";cout<<endl
using namespace std;
typedef pair<int,int> P;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 100005;
ll lpa[40],lpb[40];
double dpa[40],dpb[40];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m,a,b,p,q;
cin >> n >> m >> a >> b >> p >> q;
if(a == 1 && b == 1){
ll cnt = m/(p+q);
cout << min(m-min(n,cnt)*(p+q),abs(min(n,cnt+1)*(p+q)-m)) << "\n";
}else{
ll cnt = min(n,40LL);
ll mid = cnt/2;
lpa[0] = lpb[0] = dpa[0] = dpb[0] = 1;
rep(i,cnt-1){
lpa[i+1] = lpa[i] * a;
lpb[i+1] = lpb[i] * b;
dpa[i+1] = dpa[i] * a;
dpb[i+1] = dpb[i] * b;
}
vl u,v;
rep(i,(1 << mid)){
ll val1 = 0;
double ch1 = 0;
rep(j,mid){
if((i >> j) & 1){
val1 += p*lpa[j] + q*lpb[j];
ch1 += p*dpa[j] + q*dpb[j];
}
}
if(ch1 <= 2*m){
u.pb(val1);
}
}
rep(i,(1 << (cnt-mid))){
ll val2 = 0;
double ch2 = 0;
rep(j,cnt-mid){
if((i >> j) & 1){
val2 += p*lpa[mid+j] + q*lpb[mid+j];
ch2 += p*dpa[mid+j] + q*dpb[mid+j];
}
}
if(ch2 <= 2*m){
v.pb(val2);
}
}
// svec(u);
// svec(v);
sort(all(v));
ll mn = (1LL << 60);
rep(i,len(u)){
int id = upper_bound(all(v),m-u[i]) - v.begin();
if(id > 0){
cmn(mn,m-(u[i]+v[id-1]));
}
if(id < len(v)){
cmn(mn,(u[i]+v[id])-m);
}
}
cout << mn << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
const LL INF = 1e17;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
long long n_, m_, a_, b_, p_, q_;
cin >> n_ >> m_ >> a_ >> b_ >> p_ >> q_;
LL n, m, a, b, p, q;
n = n_;
m = m_;
a = a_;
b = b_;
p = p_;
q = q_;
LL ans = INF;
if(a == 1 && b == 1){
LL k = min(n, m / (p+q));
mini(ans, abs(k*(p+q) - m));
if(k+1 < n)
mini(ans, abs((k+1)*(p+q) - m));
}
else{
LL M = min((LL)40, n);
LL M2 = M / 2;
vector<LL> as(M+1), bs(M+1);
as[0] = bs[0] = 1;
REP(i,M){
as[i+1] = (as[i]>=INF/a? INF: as[i] * a);
bs[i+1] = (bs[i]>=INF/b? INF: bs[i] * b);
}
vector<LL> xs = {0}, ys = {0};
for(int bb=0;bb<1<<M2;++bb){
LL sum = 0;
REP(i,M2)
if(bb>>i&1){
if(as[i] < INF/p)
sum += as[i]*p;
else
sum = INF;
if(bs[i] < INF/p)
sum += bs[i]*q;
else
sum = INF;
}
xs.PB(sum);
}
for(int bb=0;bb<1<<(M-M2);++bb){
LL sum = 0;
REP(i,M-M2)
if(bb>>i&1){
if(as[i+M2] < INF/p)
sum += as[i+M2]*p;
else
sum = INF;
if(bs[i+M2] < INF/p)
sum += bs[i+M2]*q;
else
sum = INF;
}
ys.PB(sum);
}
for(auto x: xs){
auto it = upper_bound(ALL(ys), m - x);
if(it != end(ys))
mini(ans, abs(x + *it - m));
if(it != begin(ys)){
--it;
mini(ans, abs(x + *it - m));
}
}
}
long long ans_ = ans;
cout << ans_ << endl;
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int main(){
int POW[22];
for(int i = 0; i < 22; i++)POW[i] = pow(2,i);
ll N,M,A,B,P,Q;
scanf("%lld %lld %lld %lld %lld %lld",&N,&M,&A,&B,&P,&Q);
if(A == 1 && B == 1){
ll num = M/(P+Q);
if(num >= N){
printf("%lld\n",M-N*(P+Q));
}else{
printf("%lld\n",min(M%(P+Q),(num+1)*(P+Q)-M)); //少し足りないと、少し多いの、差が小さい方
}
return 0;
}
vector<ll> FIRST;
ll tmp = P+Q;
ll a = 1, b = 1;
ll count = 0,over_count = 0;
double check;
while(true){
if(tmp > M)over_count++; //超過は1回だけ許す
FIRST.push_back(tmp);
count++;
if(count == N || over_count == 1)break;
check = P*a*A+Q*b*B;
if(check > (double)M)break;
a *= A;
b *= B;
tmp = P*a+Q*b;
}
//数字を2つのグループに振り分ける
vector<ll> G[2];
for(ll i = 0; i < FIRST.size(); i++){
if(i <= (FIRST.size())/2){
G[0].push_back(FIRST[i]);
}else{
G[1].push_back(FIRST[i]);
}
}
int num[2];
num[0] = (int)G[0].size();
num[1] = (int)G[1].size();
//各グループで数字を作る
vector<ll> V[2];
V[1].push_back(0);
for(int group = 0; group < 2; group++){
for(int state = 0; state < POW[num[group]]; state++){
tmp = 0;
for(int loop = 0; loop < num[group]; loop++){
if(state & (1 << loop)){
tmp += G[group][loop];
}
}
V[group].push_back(tmp);
}
sort(V[group].begin(),V[group].end());
V[group].erase(unique(V[group].begin(),V[group].end()),V[group].end());
}
ll ans = M,tmp_ans;
int left,right,m,loc;
for(int i = 0; i < V[0].size(); i++){
if(V[0][i] >= M){
ans = min(ans,V[0][i]-M);
break;
}
//2分探索で、和がMを超えない、最大のindexを求める
left = 0,right = (int)V[1].size()-1,m = (left+right);
loc = 0;
while(left <= right){
if(V[0][i]+V[1][m] <= M){
loc = m;
left = m+1;
}else{
right = m-1;
}
m = (left+right)/2;
}
tmp_ans = (M-(V[0][i]+V[1][loc]));
if(loc < (int)V[1].size()-1){
tmp_ans = min(tmp_ans,V[0][i]+V[1][loc+1]-M);
}
ans = min(ans,tmp_ans);
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
using namespace std;
typedef long long ll;
typedef __int128_t dll;
int main() {
ll n,m,a,b,p,q;
cin>>n>>m>>a>>b>>p>>q;
if (a == b && b == 1) {
if (n > m/(p+q))
cout << min(m%(p+q), ((p+q)-(m%(p+q)))%(p+q)) << endl;
else
cout << m-(p+q)*n << endl;
return 0;
}
vector<ll> nums;
dll pa = p, qb = q;
REP(i,n) {
if (pa + qb >= 2*m) break;
nums.push_back(pa+qb);
pa *= a;
qb *= b;
}
int l = nums.size();
int s1 = l/2, s2=l-s1;;
vector<ll> lsr(begin(nums),begin(nums)+s1);
vector<ll> gtr(begin(nums)+s1,end(nums));
vector<ll> l1(1<<s1),l2(1<<s2);
REP(i,1<<s1) REP(j,s1)
if((i>>j)&1) l1[i] += lsr[j];
REP(i,1<<s2) REP(j,s2)
if((i>>j)&1) l2[i] += gtr[j];
sort(begin(l2),end(l2));
ll mn = m;
REP(i,1<<s1) {
auto itr = lower_bound(begin(l2),end(l2),m-l1[i]);
if(itr!=end(l2)) mn=min(mn,(l1[i]+*itr)-m);
if(itr!=begin(l2)) mn=min(mn,m-(l1[i]+*prev(itr)));
}
cout << mn << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <sstream>
using namespace std;
string toString(int n){
ostringstream os;
os << n;
return os.str();
}
int main(){
int Q;
string N;
cin >> Q;
while(Q--){
cin >> N;
int i;
for(i = 0 ; N.size() != 1 ; i++){
int ans = -1;
for(int j = 1 ; j < N.size() ; j++){
string a = N.substr(0, j);
string b = N.substr(j);
ans = max(ans, atoi(a.c_str()) * atoi(b.c_str()));
}
N = toString(ans);
}
cout << i << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int c;
int seisu_1(int n){
if(0<=n && n<10) return c;
if(n == (n/10)*(n%10)) return -1;
else{
int nmax=(n/10)*(n%10), m;
for(int j=10; j<=n; j*=10){
m = (n/j)*(n%j);
if(nmax<m) nmax = m;
}
c++;
return seisu_1(nmax);
}
}
int main(void){
int Q, n;
cin >> Q;
for(int i=1; i<=Q; i++){
c = 0;
cin >> n;
cout << seisu_1(n) << endl;
}
return 0;
}
|
#include <iostream>
#include <math.h>
using namespace std;
int main(){
int q;
cin >> q;
while( q-- ){
int count = 0;
int n;
cin >> n;
while( n >= 10 ){
int d = 0;
int max = 0;
while( d++ < 6){
int a, b;
a = n / pow( 10, d );
b = n % (int)pow( 10, d );
if( max < a * b ) max = a * b;
}
count++;
n = max;
}
cout << count << endl;
}
}
|
#include <cstdio>
#include <cstring>
int q,n;
bool data[1000001];
int main(void){
scanf("%d",&q);
for(int i=0;i<q;i++){
scanf("%d",&n);
memset(data,false,sizeof(data));
int x=n,next,cnt=0;
while(1){
if(data[x]){
printf("-1\n");
break;
}
if(x<=9){
printf("%d\n",cnt);
break;
}
data[x]=true;
next=-1;
int a=x,b=0,c=1;
while(a>0){
b=b+(a%10)*c;
a/=10;
if(a*b>next)next=a*b;
c*=10;
}
x=next;
cnt++;
}
}
return 0;
}
|
#include<iostream>
using namespace std;
#define rep(i, j) for(int i = 0; i < j; i++)
int retMax(int n){
int ret = -1;
for(int i = 10; n % i != n; i *= 10){
int a = n / i, b = n % i;
ret = max(ret, a * b);
}
return ret;
}
int main(){
int q;
cin >>q;
for(int z = 0; z < q; z++){
int n, ans = 0; cin >>n;
while(n >= 10){
int befn = n;
n = retMax(n);
ans++;
if(befn < n){
ans = -1;
break;
}
}
cout <<ans <<endl;
}
return 0;
}
|
#include <stdio.h>
#include <set>
#include <algorithm>
using namespace std;
int solve(int n) {
int c = 0;
set<int> vis;
while (n >= 10 && vis.count(n) == 0) {
vis.insert(n);
int nx = 0, d = 10;
while (d <= n) {
nx = max(nx, (n%d)*(n/d));
d *= 10;
}
n = nx;
c++;
}
if (n < 10) return c;
return -1;
}
int main() {
int Q;
scanf("%d", &Q);
while (Q--) {
int n;
scanf("%d", &n);
printf("%d\n", solve(n));
}
return 0;
}
|
#include<iostream>
#include<math.h>
using namespace std;
int ans(int n){
if(n/10==0)return 0;
int ma=0;
for(int i=0;i<=6;i++){
int tmp=pow(10,i);
ma=max(ma,(n/tmp)*(n%tmp));
}
return ans(ma)+1;
}
int main(){
int q;
cin>>q;
for(int i=0;i<q;i++){
int n;
cin>>n;
cout<<ans(n)<<endl;
}
}
|
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int main() {
int q; scanf("%d", &q);
rep(i, q) {
int n; scanf("%d", &n);
map<int, bool>mp;
for (int cnt = 0;; cnt++) {
if (n < 10) {
printf("%d\n", cnt);
break;
}
mp[n] = true;
int Max = 0;
string s = to_string(n);
for (int i = 1; i < s.size(); i++) {
string s1, s2;
rep(j, i)s1 += s[j];
for (int j = i; j < s.size(); j++)s2 += s[j];
Max = max(Max, stoi(s1)*stoi(s2));
}
if (mp[Max]) {
puts("-1");
break;
}
n = Max;
}
}
}
|
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int q, n;
int keta(int n){
int count=1;
while (1){
if (n>=10){
count++;
n = n/10;
}
else break;
}
return count;
}
int maain(){
cin >> q;
for (int i=0;i<q;i++){
cin >> n;
cout << keta(n) << endl;
}
return 0;
}
int main(){
int a,b;
cin >> q;
for (int i=0;i<q;i++){
cin >> n;
int ans=0;
while (n>=10){
int max=0;
int ket=keta(n);
for (int j=1;j<ket;j++){
a=n/pow(10,j);
b=n-a*pow(10,j);
if (a*b>max) max=a*b;
}
n=max;
ans++;
}
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
int table[1050000];
int solve(int x){
if(table[x] != -2)return table[x];
if(x < 10)return 0;
int &res = table[x];
res = -1;
int p = 0;
for(int i = 1;i <= x;i *= 10){
p = max(p, (x / i) * (x % i));
}
res = solve(p);
if(res >= 0)res++;
return res;
}
int main(){
int q, n;
fill(table, table + 1050000, -2);
cin >> q;
while(q--){
cin >> n;
cout << solve(n) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int maxi(int n)
{
if (n <= 9) return (0);
int b = 1;
int c = 0;
int ma = 0;
while (n > 9){
c += (n % 10) * b;
b *= 10;
n /= 10;
ma = max(ma, n * c);
}
return (maxi(ma) + 1);
}
int main()
{
int Q;
scanf("%d", &Q);
while (Q--){
int n;
scanf("%d", &n);
printf("%d\n", maxi(n));
}
return (0);
}
|
#include <bits/stdc++.h>
int e,n,c,k,i;
using namespace std;
int main() {
cin>>e;
while(e--){
cin>>n;
c=0;
while(n>9){
int m=0,b=1;
for(c++,i=0;i<5;i++){
b*=10;
k=(n/b)*(n%b);
if(k>m)m=k;
}
n=m;
}
cout<<c<<endl;
}
}
|
#include <iostream>
using namespace std;
int solve(int n) {
int d, next_n;
int count = 0;
while(n >= 10) {
++count;
d = 1000000;
next_n = 0;
while(d > 0) {
next_n = max(next_n, (n / d) * (n % d));
d /= 10;
}
n = next_n;
}
return count;
}
int main() {
int Q, N;
cin >> Q;
for(int i = 0; i < Q; ++i) {
cin >> N;
cout << solve(N) << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
#include <set>
using namespace std;
string nxt(string s) {
int ma = -1;
for (int i = 1; i < s.length(); i++) {
string s1 = s.substr(0, i);
string s2 = s.substr(i);
int mul = stoi(s1) * stoi(s2);
ma = max(ma, mul);
}
return to_string(ma);
}
int solve(string s) {
int cnt = 0;
set<string> his;
while (s.length() > 1) {
cnt++;
his.insert(s);
s = nxt(s);
if (his.count(s)) return -1;
}
return cnt;
}
int main() {
int Q; cin >> Q;
while (Q--) {
string N; cin >> N;
cout << solve(N) << endl;
}
return 0;
}
|
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
using namespace std;
int main(){
int Q,N,count,tmp,max,S;
bool FLG;
scanf("%d",&Q);
bool* table = new bool[1000001];
for(int loop = 0; loop < Q; loop++){
count = 0;
scanf("%d",&N);
for(int i = 0; i <= N;i++)table[i] = false;
table[N] = true;
FLG = false;
while(true){
if(N/10 == 0)break;
max = 0;
for(S = 10;N/S != 0; S *= 10){
tmp = (N/S)*(N%S);
max = (max >= tmp)?max:tmp;
}
N = max;
if(table[N] == true){
FLG = true;
break;
}else{
table[N] = true;
count++;
}
}
if(FLG){
printf("-1\n");
}else{
printf("%d\n",count);
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int q;
cin>>q;
for(int x=0;x<q;x++){
int n;
cin>>n;
int ans=0;
while(n/10>0){
int nn=0;
string s=to_string(n);
for(int i=1;i<s.size();i++){
string a,b;
for(int j=0;j<i;j++)a.push_back(s[j]);
for(int j=i;j<s.size();j++)b.push_back(s[j]);
nn=max(nn,stoi(a)*stoi(b));
n=nn;
}
ans++;
}
cout<<ans<<endl;
}
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
using namespace std;
int n;
int main()
{
cin>>n;
for(;n--;)
{
int a;cin>>a;
int cnt=0;
while(a>=10)
{
int nexta=0;
for(int i=10;i<=a;i*=10)
{
int now=a%i*(a/i);
nexta=max(nexta,now);
}
a=nexta;
cnt++;
}
cout<<cnt<<endl;
}
}
|
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
int main()
{
int q; cin>>q;
while(q--)
{
int n; cin>>n;
set<int> used;
int ans=0;
while(used.find(n)==used.end()&&9<n)
{
int next=0,r=0;
used.insert(n);
int mul=1;
while(1)
{
r+=n%10*mul;
n/=10;
mul*=10;
if(n==0) break;
next=max(next,r*n);
}
n=next;
ans++;
}
if(n<=9) cout<<ans<<endl;
else cout<<-1<<endl;
}
return 0;
}
|
#include <iostream>
#include <map>
#include <algorithm>
using namespace std;
//http://hadrori.hateblo.jp/entry/aoj2424
//10の累乗で割った余りと商を掛けて次の数にするだけ。
int main(){
int q;
for(cin>>q;q;q--){
int n;
cin>>n;
int t=n;
int cnt=0;
while(t/10>0){
int d=10;
int mx=0;
while(t/d>0){
mx=max(mx,(t/d)*(t%d));
d*=10;
}
t=mx;
if(t==n){
cnt=n;
break;
}
cnt++;
}
cout<<cnt<<endl;
}
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
int dfs(int n){
if(n<10) return 0;
int res=0,a,ten=1;
for(a=n%10,n/=10;n>0;ten*=10,a+=n%10*ten,n/=10) res=max(res,a*n);
return dfs(res)+1;
}
int main(){
int q; scanf("%d",&q);
while(q--){ int n; scanf("%d",&n); printf("%d\n",dfs(n)); }
return 0;
}
|
#include <iostream>
using namespace std;
int f(int n) {
if (n < 10) return 0;
int next = 0;
for (int k = 10; n / k >= 1; k *= 10) {
next = max(next, (n / k) * (n % k));
}
return f(next) + 1;
}
int main() {
int Q; cin >> Q;
for (int t = 0; t < Q; ++t) {
int N; cin >> N;
cout << f(N) << endl;
}
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < (int) (n); i++)
#define ALL(v) (v).begin(), (v).end()
#define INF 1e9
using namespace std;
int main(){
int q;
cin >> q;
REP(i, q){
int n;
cin >> n;
int res = 0;
while(n >= 10){
int divisor = 10;
int maxim = 0;
REP(j, 6){
if(divisor >= n) break;
maxim = max(maxim, (n / divisor) * (n % divisor));
divisor *= 10;
}
n = maxim;
res++;
// cout << n << endl;
if(res > 100) { res = -1; break; }
}
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define lp(i,n) for(int i=0;i<n;i++)
int main(){
int n;
cin>>n;
lp(z,n){
int a,b=0,count=0;
cin>>a;
vector<int> lis;
while(1){
if(a/10==0) break;
int i=1;
while(1){
if(a/10==0) break;
b+=a%10*i;
a/=10;
lis.push_back(b*a);
i*=10;
}
b=0;
sort(lis.begin(),lis.end());
reverse(lis.begin(),lis.end());
a=lis[0];
lis.clear();
count++;
}
cout<<count<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int Q, N;
cin >> Q;
while(Q--){
cin >> N;
int count = 0;
while(N >= 10){
count++;
int best = 0;
int p = 1;
while(p < N){
best = max(best, (N % p) * (N / p));
p *= 10;
}
N = best;
}
cout << count << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstring>
#include <string>
#include <cstdlib>
#include <sstream>
using namespace std;
int n;
string calc(string x){
int Max=0;
for(int i=1;i<x.size();i++){
Max = max(Max, atoi(x.substr(0, i).c_str()) * atoi(x.substr(i).c_str()));
}
stringstream ss;
ss << Max;
return ss.str();
}
int main(){
int i,j;
string x;
cin >> n;
while(n--){
int ans=0;
cin >> x;
for(;x.size()>1;ans++) x=calc(x);
cout << ans << endl;
}
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
char s[1024];
int Number(int l, int r)
{
int n = 0;
for (int i = l; i <= r; i++){
n = n * 10 + s[i] - '0';
}
return (n);
}
int main()
{
int N;
scanf("%d", &N);
for (int c = 0; c < N; c++){
scanf("%s", s);
int cnt = 0;
while (s[1] != '\0'){
int ma = 0;
int len = strlen(s);
for (int m = 0; m < len - 1; m++){
ma = max(ma, Number(0, m) * Number(m + 1, len - 1));
}
sprintf(s, "%d", ma);
cnt++;
}
printf("%d\n", cnt);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
for (int i = 0; i < n; ++i) {
string s; cin >> s;
int c = 0;
while (s.length() >= 2) {
int vm = -1;
for (int j = 1; j < s.length(); ++j) {
int t1 = atoi(s.substr(0, j).c_str());
int t2 = atoi(s.substr(j, s.length()-j).c_str());
vm = max(vm, t1*t2);
}
++c;
s = to_string(vm);
}
cout << c << endl;
}
}
|
#include <string>
#include <cstdio>
#include <cstdlib>
char S[9];
int main(){
int q,n,r,i;
for(scanf("%d",&q);q--;printf("%d\n",r))
for(r=0,scanf("%d",&n);n>9;r++){
sprintf(S,"%d",n);n=0;
std::string s=S;
for(i=1;i<s.length();i++)n=std::max(n,atoi(s.substr(0,i).c_str())*atoi(s.substr(i).c_str()));
}
}
|
#include<iostream>
#include<algorithm>
//#include<math.h>
using namespace std;
//int i=1;
int n;
int i=1;
int temp=0;
int ans=0;
int pow(int a,int b){
int ans=1;
if(b==0){
return 1;
}
else{
for(int i=0;i<b;i++){
ans = a*ans;
}
return ans;
}
}
int solve(int a){
temp=0;
i=1;
while(1){
if(a%pow(10,i)==a)break;
else{
temp=max(temp,(a%pow(10,i))*((a-a%pow(10,i))/pow(10,i)));
i++;
}
}
return temp;
}
int main(){
cin >> n;
for(int i=0;i<n;i++){
cin >> temp;
while(1){
if(temp%10==temp)break;
else{
solve(temp);
ans++;
}
}
cout << ans << endl;
ans=0;
}
}
|
#include <cstring>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#include <cstdio>
inline int getInt(){ int s; scanf("%d", &s); return s; }
#include <set>
using namespace std;
int dp[1000000 + 100000];
int solve(int n){
if(n < 10) return 0;
if(dp[n] != -1) return dp[n];
int now = 0;
int nn = n;
int next = 0;
int tmp = 1;
while(true){
now += tmp * (nn % 10);
nn /= 10;
if(nn == 0) break;
next = max(next, now * nn);
tmp *= 10;
}
return dp[n] = solve(next) + 1;
}
int main(){
const int q = getInt();
memset(dp, -1, sizeof(dp));
REP(i,q)
printf("%d\n", solve(getInt()));
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
using namespace std;
typedef long long ll;
int INF = (1LL << 30) - 1;
int MOD = 1e9+7;
string to_str(ll A){
stringstream ss;
ss << A;
return ss.str();
}
int func(string s){
if(s.length() == 1)return 0;
ll maxi = 0;
rep(i,1,s.length()){
ll num = stoi(s.substr(0,i) ) * stoi(s.substr(i) );
maxi = max(maxi, num);
}
return 1 + func(to_str(maxi));
}
int main(){
int N;
cin >> N;
rep(i,0,N){
int num;
cin >> num;
cout << func(to_str(num) ) << endl;
}
}
|
#include <cstdio>
#include <cstdint>
#include <string>
#include <algorithm>
#include <vector>
intmax_t f(intmax_t r) {
std::string s = std::to_string(r);
intmax_t res = 0;
for (size_t i = 1; i < s.length(); ++i) {
std::string s0 = s.substr(0, i);
std::string s1 = s.substr(i);
intmax_t r0 = std::stoi(s0);
intmax_t r1 = std::stoi(s1);
res = std::max(res, r0*r1);
}
if (res > 1e9) return -1;
return res;
}
int testcase_ends() {
intmax_t R;
scanf("%jd", &R);
int res = 0;
while (R > 9) {
R = f(R);
++res;
}
printf("%d\n", res);
return 0;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) testcase_ends();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n;
cin >> q;
for(int i = 0; i < q; ++i){
cin >> n;
int cnt = 0;
while(cnt < 1000){
if(n <= 9)
break;
string base = to_string(n);
int next = 0;
for(int i = 1; i < base.size(); ++i){
string t = base;
int l = stoi(t.substr(0, i));
int r = stoi(t.substr(i, t.size() - i));
next = max(next, l * r);
}
n = next;
cnt++;
}
if(cnt >= 1000)
cout << "-1" << endl;
else
cout << cnt << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <utility>
#include <cstring>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
typedef long long ll;
int main() {
int q;
cin >> q;
while(q--) {
int n, cnt=0;
cin >> n;
while(n>=10 && cnt<10000) {
int b = floor(log(n) / log(10.0));
int maxi = 0;
for(int i=0; i<b; i++) {
int p = pow(10,i+1);
int x = n % p;
int y = (n-x) / p;
maxi = max(maxi, x*y);
}
n = maxi;
cnt++;
}
cout << (cnt==10000 ? -1 : cnt) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int Q;
cin >> Q;
while(Q--){
int N;
cin >> N;
for(int i = 0; i <= 1000000; i++){
if(N / 10 == 0){
cout << i << endl;
break;
} else if(i == 1000000){
cout << -1 << endl;
break;
}
int fore, back;
int next = -1;
for(int j = 10; j <= N; j *= 10){
fore = N / j;
back = N % j;
next = max(next, fore*back);
}
N = next;
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
int num,cnt=0;
cin>>num;
while(1){
int max=0;
if(num/10==0)break;
for(int j=10;num/j>0;j*=10){
int a=num/j,b=num%j;
if(a*b>max)max=a*b;
}
num=max;
cnt++;
}
cout<<cnt<<endl;
}
return 0;
}
|
#include <stdio.h>
#define max(a,b) a > b ? a : b
int main(void){
int max, t, i, k, n, count, m;
scanf("%d",&m);
for(k = 0;k < m;k++){
scanf("%d",&n);
count = 0;
while(n / 10){
max = 0x80000000;
for(i = 10;n / i != 0;i*=10){
t = (n / i) * (n - (n / i) * i);
max = max(t,max);
}
n = max;
count++;
}
printf("%d\n",count);
}
return 0;
}
|
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int Q;
scanf("%d", &Q);
for (int i=0;i<Q;i++) {
int N;
scanf("%d", &N);
bool loop = false;
vector<int> n;
n.push_back(N);
while (N/10 > 0) {
const string sN = to_string(N);
N = 0;
for (int j=1;j<sN.size();j++)
N = max(N, stoi(sN.substr(0,j))*stoi(sN.substr(j)));
if (find(n.begin(), n.end(), N) != n.end()) {
loop = true;
break;
}
n.push_back(N);
}
if (loop) puts("-1");
else printf("%d\n", (int)n.size()-1);
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <string>
#include <queue>
#include <map>
#include <stack>
using namespace std;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int main() {
int r[8]={1,10,100,1000,10000,100000,1000000,10000000};
int q,n,ans;
cin>>q;
for(int z=0;z<q;z++){
ans=0;
cin>>n;
while(n>=10){
int m=0;
for(int i=1;i<7;i++){
if((n%(r[i]))*(n/(r[i]))>m) m=(n%(r[i]))*(n/(r[i]));
}
n=m;
ans++;
}
cout<<ans<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int divider(string str){
int maxi=-1;
for(int k=0;k < str.size();k++){
string s1 = str.substr(0,k);
string s2 = str.substr(k);
maxi = max(maxi, atoi(s1.c_str())*atoi(s2.c_str()));
}
if(maxi/10) return maxi;
else return 0;
}
string changer(int a){
stringstream ss;
ss << a;
return ss.str();
}
int main()
{
int n;
cin >> n;
for(int i=0;i < n;i++){
string str;
cin >> str;
int cnt=0;
int judge;
string ss=str;
while(judge = divider(ss)){
ss = changer(judge);
cnt++;
}
if(str.size() != 1){
cout << cnt+1 << endl;
}
else cout << cnt << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int ketasuu(int n) {
int ans = 0;
while(n > 0){
ans++;
n = n / 10;
}
return ans;
}
int A[7] = {1,10,100,1000,10000,100000,1000000};
int solve_loop(int n) {
int a1, a2;
int ans = 0;
int k = ketasuu(n);
if(k == 1 || k == 0) return -1;
for(int i = 1; i < k; i++) {
a1 = n / A[i];
a2 = n % A[i];
ans = max(ans,a1*a2);
}
return ans;
}
int solve(int num) {
int output = 0;
while(solve_loop(num) != -1){
output++;
num = solve_loop(num);
}
return output;
}
int main() {
int Q, N;
cin >> Q;
for(int i = 0; i < Q; i++) {
cin >> N;
cout << solve(N) << endl;
}
}
|
#include <iostream>
#include <cassert>
#define REP(i,l,n) for(int i=l;i<n;++i)
#define rep(i,n) REP(i,0,n)
int ans;
int Q,n;
using namespace std;
int main() {
cin >> Q;
rep(i,Q){
cin >> n;
ans = 0;
while(n > 9){
ans++;
int max = 0,div = 1;
rep(j,5){
div *= 10;
int post = (n/div)*(n%div);
if(post>max) max = post;
}
n = max;
}
cout << ans << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
int main(){
int n;
cin >> n;
for(int i=0;i<n;i++){
int a;
set<int> s;
bool f = false;
cin >> a;
int j;
for(j=0;a>=10;j++){
int cnt = 0;
for(int k=10;k<=a;k*=10) cnt = max(cnt,(a/k)*(a%k));
if(s.find(cnt) != s.end()){
f = true;
break;
} else {
a = cnt;
s.insert(cnt);
}
}
cout << (f ? -1 : j) << endl;
}
}
|
#include <iostream>
using namespace std;
int main()
{
int Q;
cin >> Q;
for (int ite = 0; ite < Q; ite++) {
long long int N,res = 0;
cin >> N;
while (N >= 10) {
long long int max = 0;
for (long long int i = 1; i <= N; i *= 10) {
if (max < (N % i) * (N / i)) {
max = (N % i) * (N / i);
}
}
N = max;
res++;
}
cout << res << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
for(int q=0;q<n;q++) {
int s;
cin >> s;
int t = s;
int a[2],max;
int count = 0;
while(t >= 10) {
count++;
a[0] = t % 10;
t /= 10;
a[1] = t;
max = a[0] * a[1];
int k = 10;
// cout << a[0] <<"&"<< a[1] << "||"<<a[0]*a[1]<<endl;
while(t) {
a[0] += k*(t%10);
k *=10;
t /= 10;
a[1] = t;
// cout << a[0] <<"&"<< a[1] << "||"<<a[0]*a[1]<<endl;
if(a[0] * a[1] > max) max = a[0]*a[1];
}
t = max;
if(count > 50000) break;
}
if(t < 10) cout << count << endl;
else cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
typedef long long ll;
ll rec(ll a){
ll m=-1,k=10;
while(1){
if(a/k==0)break;
m=max(m,a/k*(a%k));
k*=10;
}
return m;
}
int main(){
ll q,n;
cin>>q;
while(q--){
int cnt=0;
cin>>n;
while(n>=10){
n=rec(n);
// cout<<n<<endl;
cnt++;
}
cout<<cnt<<endl;
}
}
|
#include <iostream>
#include <map>
#include <cstdlib>
#include <sstream>
using namespace std;
int main(){
int Q;
cin >>Q;
while(Q--){
int n;
cin >>n;
map<int,int>memo;
int ans = 0;
while(!memo[n] && n >= 10){
memo[n] =true;
int next = 0;
stringstream ss;
ss << n;
string t =ss.str();
for(int i = 0 ; i < t.size()-1 ; i++){
string a = t.substr(0,i+1);
string b = t.substr(i+1);
int A = atoi(a.c_str());
int B = atoi(b.c_str());
next = max(next,A*B);
}
ans++;
n = next;
}
if( n >= 10 ){
cout << -1 << endl;
}else{
cout << ans << endl;
}
}
}
|
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
int main()
{
int q;
cin >> q;
for(int i=0; i<q; i++){
int n;
cin >> n;
int count=0;
set<int> memo;
memo.insert(n);
bool bloop = false;
while(n > 9){
int next = 0;
for(int j=10; j<n; j*=10){
int a = n/j;
int b = n%j;
next = max(next,a*b);
}
if(!memo.insert(next).second){
bloop = true;
break;
}
n = next;
count++;
}
if(bloop) cout << -1 << endl;
else cout << count << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
// 方針：-1が出力されることはない。
// 普通に数えて終わり。
int step (int L) {
string S = to_string(L);
int res = 0;
for (auto i=1; i<S.size(); i++) {
int I1 = stoi(S.substr(0, i));
int I2 = stoi(S.substr(i, S.size()-i));
int temp = I1 * I2;
// cerr << "I1 = " << I1 << ", I2 = " << I2 << ", temp = " << temp << endl;
if (res < temp) res = temp;
}
return res;
}
int count_step (int L) {
int res = 0;
for ( ; L>=10 ; res++) {
// cerr << "res = " << res << endl;
L = step(L);
}
return res;
}
int main() {
int Q;
cin >> Q;
for (auto i=0; i<Q; i++) {
int N;
cin >> N;
cout << count_step(N) << endl;
}
}
|
#include <cstdio>
#include <algorithm>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
int q;
scanf("%d",&q);
rep(tt,q){
int n,cnt=0;
scanf("%d",&n);
while(true){
int d[7]={},tmp=n,i,mx=-1;
for(i=0;tmp>0;i++){
d[i]=tmp%10;
tmp/=10;
}
if(i<=1) break;
for(int j=1;j<i;j++){
int l=0,r=0;
rep(k,j) l=10*l+d[j-1-k];
rep(k,i-j) r=10*r+d[i-1-k];
mx=max(mx,l*r);
}
n=mx;
cnt++;
}
printf("%d\n",cnt);
}
}
|
#include<iostream>
#include<string>
#include<math.h>
using namespace std;
int main(){
int n,s;
cin>>n;
for(int i=0;i<n;i++){
cin>>s;
int count=0;
while(true){
if(s/10==0)
break;
int best=0,check=10;
for(int j=1;j<6;j++){
if((s/check)*(s%check)>best)
best=(s/check)*(s%check);
check*=10;
}
s=best;
count++;
}
cout<<count<<endl;
}
return 0;
}
|
#include <iostream>
#include <cstdlib>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(int)(b);i++)
#define rep(i,n) FOR(i,0,n)
#define dbg(x) cout<<#x<<": "<<(x)<<"\n"
void solve(string n) {
int cnt = 0;
while(stoi(n) > 9) {
int m = n.size();
int ma = -1;
for(int i=1; i<m; i++) {
string s1 = n.substr(0,i);
string s2 = n.substr(i,m-i);
if(stoi(s1) * stoi(s2) > ma) {
ma = stoi(s1) * stoi(s2);
}
}
n = to_string(ma);
cnt++;
}
cout << cnt << "\n";
}
int main() {
int q; cin>>q;
rep(i,q) {
string n; cin>>n;
solve(n);
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
int q;
std::string str, b, e;
int solve(int m) {
int cnt = 0;
while (1) {
str = std::to_string(m);
if (str.size() == 1)
break;
b.clear();
e = str;
int l, r, max = 0;
for (int i = 0; i < str.size() - 1; ++i) {
b += str[i];
e.erase(e.begin());
l = std::stoi(b);
r = std::stoi(e);
max = std::max(max, l*r);
m = max;
}
++cnt;
}
return cnt;
}
int main() {
std::cin >> q;
int n;
for (int i = 0; i < q; ++i) {
std::cin >> n;
std::cout << solve(n) << std::endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.