Problem:
Score : 300 points

Problem Statement

To make it difficult to withdraw money, a certain bank allows its customers to withdraw only one of the following amounts in one operation:

1 yen (the currency of Japan)

6 yen, 6^2(=36) yen, 6^3(=216) yen, ...

9 yen, 9^2(=81) yen, 9^3(=729) yen, ...

At least how many operations are required to withdraw exactly N yen in total?

It is not allowed to re-deposit the money you withdrew.

Constraints

1 \leq N \leq 100000

N is an integer.

Input

Input is given from Standard Input in the following format:

N

Output

If at least x operations are required to withdraw exactly N yen in total, print x.

Sample Input 1

127

Sample Output 1

4

By withdrawing 1 yen, 9 yen, 36(=6^2) yen and 81(=9^2) yen, we can withdraw 127 yen in four operations.

Sample Input 2

3

Sample Output 2

3

By withdrawing 1 yen three times, we can withdraw 3 yen in three operations.

Sample Input 3

44852

Sample Output 3

16

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <iostream>
#include <vector>
using namespace std;

//container util
//------------------------------------------
#define ALL(a)  (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
//conversion

//debug
#define dump(x)  cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
//math
//-------------------------------------------
template<class T> inline T sqr(T x) {return x*x;}

typedef long long LL;
const LL mod=1000000007;
#define MAX 10000
#define NIL -1
const LL INF = 1e9 + 7;
//-------------------------------------------


LL n;
LL b,c;
vector<LL> a(MAX);


//LL dp[100000][100000];
vector<LL> dp(100010, INF);


int main(){

    cin.tie(0);
    ios::sync_with_stdio(false);

    b = 6;
    c = 9;

    cin >> n;
    a[0] = 1;
    a[1] = 6;
    a[2] = 9;


    FOR(i,1,n){
        b = b*6;
        if( b > n) break;
        a.push_back(b);
    }

    FOR(i,1,n){
        c = c*9;
        if( c > n) break;
        a.push_back(c);

    }

    dp[0] = 0;

    for(LL i = 0; i < a.size(); i++){
        for(LL j = a[i]; j <= n; j++){   // 範囲外アクセス c[i] - j >= 0
                dp[j] = min( dp[j], dp[j - a[i]] + 1);
        }
    }

    cout << dp[n] << endl;

    return 0;
}