HDU 4898 The Revenge of the Princess’ Knight （ 2014 Multi-University Training Contest 4 ）

题意：给定一个环形字符串，让他把它分成k份，使得最大的字典序 最小。

思路：二分答案，首先很明显答案所有可能是 n*n种  排序可以先求出最长公共前缀，这样比较就只需要比较公共前缀的下一位就能比较出两种答案的字典序大小，这里公共前缀我用 （2*n）*（2*n） DP 求出 。（也可用后缀数组）。接下来就是判断了：

   这里二分出来的答案就是字典序的上界，（对于没一个位置作为起点，长度越长字典序越大）那么对于当前答案每个位置都可以求出一个能向后跳的最大值（根据如果以这个点做一个串的起点那么字典序要小于我们二分到的答案）。

  那么问题就转换成能不能找到一个起点恰好跳k次回到本身。

   首先我们假设cur[i] 为i能向右跳最大距离。如果所有cur[i]都大于0，那么我们只要找到最小需要跳的次数 x   如果x<=k 那么我们肯定就能通过调整步长使得恰好k次能到达（如果总点数小于k  当然无解）最小的k，可以通过枚举每个起点然后尽量往后跳看要几次即可。

为什么能够尽量往后跳来当最少需要的次数呢：因为如果该字符串中如果存在一个字符小于二分到的答案首字母（那就说明以这个字母开始的所有字符串字典序均小于二分到的答案），那么我们就能通过一次跳跃就完成（这里因为有枚举起点肯定会枚举到）。  如果所有字母均等于答案的首字母（这里不可能存在大于答案首字母的字符，如果存在这种字符，他必定不能往后跳，就删除了），那么每次往后跳就为最优。

那么当cur[i]==0时 表示他不能跳到别人别人也不能跳到他那么就删除这个点如果一个点跳跃区间有覆盖这个点  这跳跃区间减去1 。最多n次删除效率为(n*n)

 

#include 
#include
#include
#include
#include
#include
#define N 2010
using namespace std;
char str[N];
struct node {
    int l, r;
    int size;
    char charat(int x) {
        if (x < size)
            return str[l + x];
        else
            return 0;
    }
} s[N * N];
int lcp[N][N];
int n, k;
int min(int x, int y) {
    return x < y ? x : y;
}
int max(int x, int y) {
    return x > y ? x : y;
}
int LCP(node a, node b) {
    int tmp = lcp[a.l][b.l];
    tmp = min(tmp, a.size);
    tmp = min(tmp, b.size);
    return tmp;
}
bool cmp(node a, node b) {
    int tmp = LCP(a, b);
    return a.charat(tmp) < b.charat(tmp);
}
void init() {
    scanf("%d%d", &n, &k);
    scanf(" %s", str);
    for (int i = n; i < n * 2; ++i)
        str[i] = str[i - n];
    for (int i = 0; i <= n + n; ++i)
        lcp[i][n + n] = lcp[n + n][i] = 0;
    for (int i = n + n - 1; i >= 0; --i)
        for (int j = n + n - 1; j >= 0; --j) {
            if (str[i] == str[j])
                lcp[i][j] = lcp[i + 1][j + 1] + 1;
            else
                lcp[i][j] = 0;
        }

}
bool check(int mid) {
    vector<int> cur;
    for (int i = 0; i < n; ++i) {
        int tmp = lcp[s[mid].l][i];
        if (tmp >= s[mid].size) {
            cur.push_back(s[mid].size);
            continue;
        }
        if (s[mid].charat(tmp) > str[i + tmp])
        {
            cur.push_back(n);
        }
        else
            cur.push_back(tmp);
    }
    while (true) {
        int flag = 1;
        for (int i = 0; i < cur.size(); ++i) {
            if (cur[i] == 0) {
                flag = 0;
                for (int j = 0; j < i; ++j)
                    if (j + cur[j] >= i)
                        cur[j]--;
                for (int j = i + 1; j < cur.size(); ++j)
                    if (j + cur[j] >= i + cur.size())
                        cur[j]--;


                cur.erase(i + cur.begin());
                break;
            }
        }
        if (flag)
            break;
    }
    if (cur.size() < k)
        return false;
    int len = cur.size();
    for (int i = 0; i < cur.size(); ++i) {

        int cnt = 0;
        for (int j = i; j < i + len; j += cur[j % len])
            cnt++;

        if (cnt <= k)
            return true;
    }

    return false;
}
void solve() {
    int tail = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = i; j < i + n; ++j) {
            s[tail].size = j - i + 1;
            s[tail].l = i;
            s[tail++].r = j;
        }
    }
    sort(s, s + tail, cmp);
    int l = 0, r = tail - 1;
    while (r - l > 1) {
        int mid = (l + r) >> 1;
        if (check(mid))
            r = mid;
        else
            l = mid;
    }
    int ans;
    if (check(l))
        ans = l;
    else
        ans = r;
    for (int i = 0; i < s[ans].size; ++i)
        printf("%c", s[ans].charat(i));
    puts("");
}
int main() {
    int tt;
    scanf("%d", &tt);
    while (tt--) {
        init();
        solve();
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/L-Ecry/p/3888396.html