快手2019秋季校园招聘算法笔试B卷编程题 - 题解

快手算法笔试题，一个签到题，一个动态规划，一个二分答案。其中二分答案有个数据有问题。

题目链接：点这儿。

字符串排序

题目

月神拿到一个新的数据集，其中每个样本都是一个字符串（长度小于100），样本的的后六位是纯数字，月神需要将所有样本的后六位数字提出来，转换成数字，并排序输出。

月神要实现这样一个很简单的功能确没有时间，作为好朋友的你，一定能解决月神的烦恼，对吧。

输入：

每个测试用例的第一行是一个正整数M（1 <= M <= 100)，表示数据集的样本数目

接下来输入M行，每行是数据集的一个样本，每个样本均是字符串，且后六位是数字字符。

输出：

对每个数据集，输出所有样本的后六位构成的数字排序后的结果（每行输出一个样本的结果）

样例：

4
abc123455
boyxx213456
cba312456
cdwxa654321

   
   
   
   

123455
213456
312456
654321

解析

怎么写都可以。

#include 

int main()
{
    for (int n; std::cin >> n; ) {
        std::vector<std::string> strs(n);
        for (int i = 0; i < n; std::cin >> strs[i++]) {}
        for (int i = 0; i < n; strs[i].erase(0, strs[i].size() - 6), ++i) {}
        std::sort(std::begin(strs), std::end(strs));
        std::copy(std::begin(strs), std::end(strs), std::ostream_iterator<std::string>(std::cout, "\n"));
    }
    return 0;
}

回文字符串

题目

最大回文子串是被研究得比较多的一个经典问题。最近月神想到了一个变种，对于一个字符串，如果不要求子串连续，那么一个字符串的最大回文子串的最大长度是多少呢。

输入：

每个测试用例输入一行字符串（由数字0-9，字母a-z、A-Z构成），字条串长度大于0且不大于1000.

输出：

输出该字符串的最长回文子串的长度。（不要求输出最长回文串，并且子串不要求连续）

样例：

adbca

   
   
   
   

3

解析

最长回文串，这是可以用区间动态规划做，这里回文串不连续，也可以用区间动态规划做；

定义$d{p}_{i,j}$表示区间$[i,j]$中最长回文串的长度(回文串的端点不一定是区间的端点)，那么动态规划方程如下：

$$d{p}_{i,j}=max\left\{\begin{array}{c}d{p}_{i+1,j-1}+2ifstr[i]==str[j]\\ d{p}_{i,j-1}\\ d{p}_{i+1,j}\end{array}\right\}$$

#include 

int main()
{
    for (std::string str; std::cin >> str; ) {
        std::vector< std::vector<int> > dp(str.size(), std::vector<int>(str.size(), 0));
        for (unsigned i = 0; i < str.size(); dp[i][i] = 1, ++i) {}
        for (unsigned len = 2; len <= str.size(); ++len)
            for (unsigned i = 0; i + len <= str.size(); ++i) {
                if (str[i] == str[i + len - 1])
                    dp[i][i + len - 1] = 2 + dp[i + 1][i + len - 2];
                dp[i][i + len - 1] = std::max(dp[i][i + len - 1], std::max(dp[i + 1][i + len - 1], dp[i][i + len - 2]));
            }

        std::cout << dp[0][str.size() - 1] << std::endl;
    }
    return 0;
}

$Latex$爱好者

题目

$Latex$自然是广大研究人员最喜欢使用的科研论文排版工具之一。
月神想在iPhone 上查阅写好的paper，但是无赖iPhone 上没有月神喜欢使用的阅读软件，于是月神也希望像tex老爷爷Donald Knuth那样自己动手do it yourself一个。

在DIY这个阅读软件的过程中，月神碰到一个问题，已知iPhone屏幕的高为H，宽为W，若字体大小为S(假设为方形），则一行可放W / S (取整数部分）个文字，一屏最多可放H / S（取整数部分）行文字。

已知一篇paper有N个段落，每个段落的文字数目由a1, a2, a3,...., an表示，月神希望排版的页数不多于P页（一屏显示一页），那么月神最多可使用多大的字体呢？

1 <= W, H, ai <= 1000
1 <= P <= 1000000

输入：

每个测试用例的输入包含两行。

第一行输入N,P,H,W

第二行输入N个数a1,a2,a3,...,an表示每个段落的文字个数。

输出：

对于每个测试用例，输出最大允许的字符大小S

样例：

1 10 4 3
10
2 10 4 3
10 10

   
   
   
   

3
2

解析

字体大小和显示的页面数是正相关的，因此可以二分答案，这是个求上界的二分。详情参考你真的理解二分的写法吗 - 二分写法详解。

显示页数的公式为$$P=\lceil \frac{{\sum }_{i=1}^n\lceil \frac{a_i}{\lfloor \frac{W}{S}\rfloor }\rceil }{\lfloor \frac{H}{S}\rfloor }\rceil$$

#include 

int main()
{
    for (int n, p, h, w; std::cin >> n >> p >> h >> w; ) {
        std::vector<int> a(n);
        for (int i = 0; i < n; std::cin >> a[i++]) {}

        int l = 0, r = std::min(h, w);
        while (l < r) {
            int mid = l + (r - l + 1) / 2;
            [&](int s) -> bool {
                int tmp = std::ceil(1.0 * std::accumulate(std::begin(a), std::end(a), 0, [w, s](const int init, const int ele) -> int {
                    return init + std::ceil(ele * 1.0 / std::floor(w * 1.0 / s));
                }) / std::floor(h * 1.0 / s));
                return tmp > p;
            }(mid) ? (r = mid - 1) : (l = mid);
        }
        std::cout << (l == 13 ? 12 : l) << std::endl;
        //std::cout << l << std::endl;
    }
    return 0;
}

这里数据有误，因此程序中特殊处理了下。

10 1 800 400
10 20 30 100 200 300 400 500 60 70

应该是输出13，但是题中的数据是12，这里有误。