everyday two problems / 3.1

T1.string

题意:

给定由小写字母组成的长度为 n 的字符串

将其所有 n * (n + 1) / 2 个子串按字典序排序

输出第 k 个子串

k > (n * (n + 1) / 2) 就输出"No such line."

1 <= n, k <= 1e5

解法:

解法很多(我不会写自动机啊

我用的解法应该算是比较简单

一位一位地去计数来确定当前位的字母

比如一开始O(n)扫描出以a开头的子串有3个

以b开头的子串有4个，而我要输出排名第5的子串

所以这一位一定是'b'，后面每一位字母的确定同理

当前位是空格的时候标志着结果输出结束

代码比较简单，可以参考

但是我们要说明一下效率

一开始脑残了误以为是O(26n)

但是其实每次while中运行次数与之前已经输出的子串在原字符串中出现的次数有关

那么我们可以考虑最坏情况，10w个'a'

这时候如果要求输出排名最靠后的子串的话效率已经O(n^2)

还好我们题目有限制 k <= 1e5

所以这种做法的最坏效率其实比较玄学(但是过了就好了233

 #include <cstdio>
 #include <vector>
 #include <cstring>

 using namespace std;

 typedef long long ll;

 vector <int> p[], pp;

 char str[];

 ll cnt[];

 int n, m;

 int main() {
     scanf("%s %d", str, &m);
     n = strlen(str);
     if(1ll * n * (n + ) /  < m) {
         puts("No such line.");
         return ;
     }
     for(int j, i = ;i < n;i ++) {
         j = str[i] - ;
         cnt[j] += n - i;
         p[j].push_back(i);
     }
     while() {
         int pos;
         for(int i = ;i <= ;i ++) {
             if(cnt[i] >= m) {
                 pos = i;
                 if(!pos) return ;
                 putchar( + i);
                 break;
             }
             else m -= cnt[i];
         }
         for(int i = ;i <= ;i ++) {
             cnt[i] = ;
             if(i != pos) p[i].clear();
         }
         cnt[] = p[pos].size();
         for(int k, j, i = ;i < p[pos].size();i ++) {
             j = p[pos][i] + ;
             if(j >= n) continue;
             k = str[j] - ;
             cnt[k] += n - j;
             if(k == pos) pp.push_back(j);
             else p[k].push_back(j);
         }
         p[pos].clear();
         for(int i = ;i < pp.size();i ++)
             p[pos].push_back(pp[i]);
         pp.clear();
     }
 }

T2.Levko and Array

题意:

给定数组a[2000]，-1e9 <= a[i] <= 1e9

最多允许修改 k(k <= n) 个元素

求 max(abs(a[i] - a[i + 1])) 的最小值

解法:

这题是看别人题解做的

猜测正解效率可能n^2

但并没有什么策略能直接由条件得到答案

满足单调，考虑二分，可能效率n^2logn，可以接受

然后这个judge函数就比较神了

考虑dp，f[i]表示先只考虑前 i 个且第 i 个不动的情况下

最少修改多少个能够让前 i 个的 max(abs(a[i] - a[i + 1])) <= mid

转移方程 f[i] = min(f[i], f[j] + i - j - 1)

转移条件是abs(f[i] - f[j]) <= (i - j) * mid

即，保证i j 都不变，(i, j)都改变

要能够使[i, j]任意相邻两个之差 <= mid才能转移

上面我们提到f[i]的意义，只考虑了前 i 个

但我们考虑最优解一定有最后连续 t 个都是要被修改的(0 <= t < n)

所以我们计算完所有 f[i] 之后

在从 1 到 n 扫一遍 f[i] + n - i

是一定能够包含最优解的

当然f[i] + n - i <= k就可以返回true了

参考的题解

 #include <cstdio>

 typedef long long ll; 

 int n, k, a[], f[];

 int min(int x, int y) {
     return x < y ? x : y;
 }

 int dis(int x, int y) {
     if(x < y) return y - x;
     return x - y;
 }

 bool judge(ll d) {
     f[] = ;
     for(int i = ;i <= n;i ++) {
         f[i] = ;
         for(int j = i- ;j;j --)
             if(dis(a[i], a[j]) <= d * (i - j))
                 f[i] = min(f[i], f[j] + i - j - );
         if(i <= k + ) f[i] = min(f[i], i - );
     }
     for(int i = ;i <= n;i ++)
         if(f[i] + n - i <= k)
             return ;
     return ;
 }

 int main() {
     scanf("%d %d", &n, &k);
     for(int i = ;i <= n;i ++)
         scanf("%d", &a[i]);
     ll l = , r = 2e9, mid;
     while(l <= r) {
         mid = (l + r) >> ;
         if(judge(mid)) r = mid - ;
         else l = mid + ;
     }
     printf("%I64d", l);
     return ;
 }