#include <bits/stdc++.h>
#include <random>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
//#define ll __int128
//#define int ll
//#dLefine char ll
//#define double ld
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<vvld> vvvld;
typedef vector<string> vst;
typedef vector<vst> vvst;
typedef pair<ld, ld> pld;

#define inmin(a, b) a = min(a, (b))
#define inmax(a, b) a = max(a, (b))
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define sqr(x) ((x) * (x))
#define fori(i, n) for(int i = 0; i < int(n); ++i)
#define SZ(a) ((int)((a).size()))
#define triple(T) tuple<T, T, T>
#define quad(T) tuple<T, T, T, T>
#define watch(x) cerr << (#x) << " = " << (x) << endl;

#ifdef MAX_HOME
#define cerr cout
#else
#define cerr if (false) cerr
#endif

const double PI = 2 * acos(0.0);
#define rand shittttty_shit
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());

const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";


template<class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
    return out << "{" << a.first << ", " << a.second << "}";
}

template<class T0, class T1>
inline istream &operator>>(istream &in, pair<T0, T1> &a) {
    return in >> a.first >> a.second;
}

template<class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
    return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a) << "}";
}

template<class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
    return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a) << ", " << get<3>(a) << "}";
}

template<class T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
    out << "[";
    fori (i, a.size())out << a[i] << vector<string>{", ", "]  "}[i + 1 == a.size()];
    return out;
}


void smain();


signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef MAX_HOME
    freopen("input.txt", "r", stdin);
    clock_t start = clock();
#endif
#ifdef HK_CUP
    freopen("finput.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    cout << setprecision(12) << fixed;
    smain();
#ifdef MAX_HOME
#ifndef HK_CUP
    cout << "\n\nTOTAL EXECUTION TIME: " << float(clock() - start) / CLOCKS_PER_SEC << endl;
#endif
#endif
    return 0;
}

const int LOG = 18;

vi anti_ord;
const int maxlen = 2e5 + 10;
int p[maxlen], cnt[maxlen], c[maxlen];
int pn[maxlen], cn[maxlen];


void sufarr(string s) {
    int n = s.size();

    int alphabet = 400;
    memset (cnt, 0, alphabet * sizeof(int));
    for (int i=0; i<n; ++i)
        ++cnt[s[i]];
    for (int i=1; i<alphabet; ++i)
        cnt[i] += cnt[i-1];
    for (int i=0; i<n; ++i)
        p[--cnt[s[i]]] = i;
    c[p[0]] = 0;
    int classes = 1;
    for (int i=1; i<n; ++i) {
        if (s[p[i]] != s[p[i-1]])  ++classes;
        c[p[i]] = classes-1;
    }

    for (int h=0; (1<<h)<n; ++h) {
        for (int i=0; i<n; ++i) {
            pn[i] = p[i] - (1<<h);
            if (pn[i] < 0)  pn[i] += n;
        }
        memset (cnt, 0, classes * sizeof(int));
        for (int i=0; i<n; ++i)
            ++cnt[c[pn[i]]];
        for (int i=1; i<classes; ++i)
            cnt[i] += cnt[i-1];
        for (int i=n-1; i>=0; --i)
            p[--cnt[c[pn[i]]]] = pn[i];
        cn[p[0]] = 0;
        classes = 1;
        for (int i=1; i<n; ++i) {
            int mid1 = (p[i] + (1<<h)) % n,  mid2 = (p[i-1] + (1<<h)) % n;
            if (c[p[i]] != c[p[i-1]] || c[mid1] != c[mid2])
                ++classes;
            cn[p[i]] = classes-1;
        }
        memcpy (c, cn, n * sizeof(int));
    }
    anti_ord.resize(n + 10);
    fori (i, n) {
        anti_ord[i] = c[i];
    }
}

const int oo = 1e9 + 10;
const int N = 1e5 + 10;

string s;
namespace BIN {
    int st[N][LOG];
    int pw2[N];

    inline int getmin(int l, int r) {
        return min(st[r][pw2[r - l + 1]], st[l + (1 << pw2[r - l + 1]) - 1][pw2[r - l + 1]]);
    }


    int solve(int len, int bound, bool output = false) {
        int n = s.size();
        vi dp(n + 1, oo);
        dp[0] = 0;
        for (int i = 1; i <= n; ++i) {
            int cur = getmin(max(0, i - len + 1), i - 1);
            dp[i] = cur + 1;
            if (i - len >= 0 && anti_ord[i - len] <= bound) {
                if (dp[i - len] + 1 < dp[i]) {
                    dp[i] = dp[i - len] + 1;
                }
            }

            st[i][0] = dp[i];
            for (int h = 1; h < LOG; ++h) {
                st[i][h] = min(st[i][h - 1], st[max(0, i - (1 << (h - 1)))][h - 1]);
            }
//        cerr << "dp[" << i << "] = " << dp[i] << endl;
        }
        return dp[n];
    }

    void init() {
        pw2[1] = 0;
        int cur = 0;
        for (int i = 2; i < N; ++i) {
            while ((1 << cur) <= i)
                cur++;
            cur--;
            pw2[i] = cur;
        }
    }
}


namespace OUT {
    pii st[N][LOG];
    int pw2[N];

    inline pii getmin(int l, int r) {
        return min(st[r][pw2[r - l + 1]], st[l + (1 << pw2[r - l + 1]) - 1][pw2[r - l + 1]]);
    }


    int solve(int len, int bound, bool output = false) {
        int n = s.size();
        vi dp(n + 1, oo);
        dp[0] = 0;
        vi from(n + 1, oo);
        for (int i = 1; i <= n; ++i) {
            pii cur = getmin(max(0, i - len + 1), i - 1);
            dp[i] = cur.first + 1;
            from[i] = cur.second;
            if (i - len >= 0 && anti_ord[i - len] <= bound) {
                if (dp[i - len] + 1 < dp[i]) {
                    dp[i] = dp[i - len] + 1;
                    from[i] = i - len;
                }
            }

            st[i][0] = {dp[i], i};
            for (int h = 1; h < LOG; ++h) {
                st[i][h] = min(st[i][h - 1], st[max(0, i - (1 << (h - 1)))][h - 1]);
            }
//        cerr << "dp[" << i << "] = " << dp[i] << endl;
        }
        if (output) {
            int c = n;
            string ans = "";
            while (c) {
                int nx = from[c];
                string cur = s.substr(nx, c - nx);
                if (cur.size() > ans.size() || (cur.size() == ans.size() && cur > ans)) {
                    ans = cur;
                }
//            cerr << cur << endl;
                c = nx;
            }
            cout << ans << '\n';
        }
        return dp[n];
    }

    void init() {
        pw2[1] = 0;
        int cur = 0;
        for (int i = 2; i < N; ++i) {
            while ((1 << cur) <= i)
                cur++;
            cur--;
            pw2[i] = cur;
        }
    }
}


void smain() {


    OUT::init();
    BIN::init();

    int k;
    cin >> k;
    k++;
    cin >> s;
    int n = s.size();
    int len = (n + k - 1) / k;
    if (len == 1) {
        cout << *max_element(ALL(s));
        return;
    }
    sufarr(s + "0");
    int l = -1, r = N - 1;
    while (r - l > 1) {
        int m = r + l >> 1;
        int cur = BIN::solve(len, m);
        if (cur <= k) {
            r = m;
        } else {
            l = m;
        }
    }
    OUT::solve(len, r, true);
}

Measured memory_bytes: 28572