[code] PTA 胡凡算法笔记 DAY030

题目 A1085 Perfect Sequence

• 题意
  从输入的n个数中选出一个序列，使得其中max <= min * p并且序列长度最长。

• 思路
  这里可以自己证明一下，先排完序之后顺序选择的策略是正确的。所以这里我们先排序，然后进行循环在i+1~n-1进行二分查找<= numbers[i]*p的下标，求出其中的最大值即为所求。复杂度为：O(nlogn)
注意：这里数列中的最大值小于最小值和p的乘积时可以直接返回n。

• Code in C++

#include <cstdio>
#include <algorithm>

#define maxn 100001
int n, numbers[maxn];

long long findm(int left, long long key)
{
    int right = n - 1;
    if (numbers[right] <= key) return n;
    while (left < right)
    {
        int mid = left + (right - left) / 2;
        if (numbers[mid] > key)
        {
            right = mid;
        }
        else
        {
            left = mid + 1;
        }
    }
    return left;
}

int main()
{
    int p;
    int ans = 1;
    scanf("%d %d", &n, &p);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d",&numbers[i]);
    }
    std::sort(numbers, numbers + n);

    for (int i = 0; i < n; ++i)
    {
        int j = findm(i + 1, (long long)p*numbers[i]);
        ans = std::max(ans, j - i);
    }

    printf("%d", ans);
    return 0;
}

---

题目 A1010 Radix

• 题意
  输入两个数，及其中一个数的进制数，判断在什么进制情况下两者相等，并输出进制数，如果不存在则输出Impossible。

• 思路
  首先为了避免重复写代码，将知道进制数的那个确定为N1。为了方便对应进制数的获取，设置一个hash数组，这里我用map建立。之后，判断相等采用都转换为10进制的方式比较。接下来就是判断二分的范围，下界为N2中最大的数+1，上界为N1和下界中最大的数+1。然后二分搜索，搜到了则输出进制数，未搜到则输出Impossible即可。
  注意：这里数据的范围可能会超过long long的范围所以需要设置一个数的界限去判断是否溢出的情况。

• Code in C++

#include <string>
#include <iostream>
#include <map>

typedef long long LL;
LL inf = (1LL << 63) - 1;
std::string n1, n2;
int index;
LL radix;
std::map<char, int> maps;

void init()
{
    for (int i = 0; i < 10; ++i)
    {
        maps[i+'0'] = i;
    }

    for (int i = 0; i < 26; ++i)
    {
        maps[i+'a'] = i + 10;
    }
}
// 将str转换为10进制，t为值上届
LL tr_10(const std::string &str, LL radix, LL t)
{
    LL ans = 0;
    int len = str.size();
    for (int i = 0; i < len; ++i)
    {
        ans = ans * radix + maps[str[i]];
        if (ans < 0 || ans > t) return -1;  // 溢出
    }
    return ans;
}


int cmp(const std::string &str, LL radix, LL t)
{
    int len = str.size();
    LL num = tr_10(n2, radix, t);
    if (num < 0) return 1;   // 溢出
    if (t > num) return -1;
    else if (t == num) return 0;
    else return 1;
}


int get_left(const std::string &str)
{
    char re = 0;
    for (int i = 0; i < str.size(); ++i)
    {
        if (str[i] > re) re = str[i];
    }
    return maps[re] + 1;
}

int binarySearch(const std::string &str, LL left, LL right, LL t)
{
    LL mid;
    while (left <= right)
    {
        mid = left + (right - left) / 2;
        int flag = cmp(str, mid, t);
        if (flag == 0) return mid;
        else if (flag == -1) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

int main()
{
    // 建立进制转换表
    init();

    std::cin >> n1 >> n2 >> index >> radix;

    // 默认知道n1的进制数
    if (index == 2)
    {
        std::swap(n1, n2);
    }

    // 判断二分查找的范围
    LL t = tr_10(n1, radix, inf);
    LL left = get_left(n2);
    LL right = std::max(left, t) + 1;
    LL ans = binarySearch(n2, left, right, t);
    if (ans == -1) printf("Impossible");
    else printf("%lld", ans);

}

---

小结

感觉对于二分搜索的一些边界值的处理的不是很好，一个是循环判断时left < right or left <= right，然后再就是缩进范围的时候是mid +/- 1还是就是mid。第一题中是right = mid，第二题是正常的。