SRM 400 Div1

这套题做的蛋疼菊紧

250

简单题。 问一个数能否被表示 成 某个素数的若干次方

我用了一个很损精度得法

其实只要判平方完了直接枚举素数就OK

vector<int>ans;
bool check(int x) {
    int m = (int)sqrt(x * 1.0) + 1;
    if(x == 2) return true;
    for(int i = 2; i <= m; i++) {
        if(x % i == 0) return false;
    }
    return true;
}
void gao(long long x) {
    int x1 = -1, x2 = -1;
    for(int i = 2; i < 60; i++) {
        int f = (int)(pow((double)x, 1.0 / i) + eps);
        long long tmp = 1;
        for(int j = 0; j < i; j++)
            tmp = tmp * (long long)f;
        if(tmp == x) {
            if(check(f)) {
                x1 = f, x2 = i;
            }
        }
    }
    if(x1 != -1) {
        ans.push_back(x1);
        ans.push_back(x2);
    }
}

500

区间DP

题目意思是说，给一个A串，一个B串

都是只包含0和1，然后用一些列reverse操作，将A变成B

reverse(i,j)表示把i,j这个区间反转

然后这系列操作有个限制

就是进行完一个操作之后，下一个操作必须在这个操作的区间中的子区间中进行，每个操作都是如此

然后这肯定是方便进行区间DP的

看有人写了一个很暴力的DFS， 没敢尝试，感觉复杂度没法算

dp[k][i][j][0]代表a串i位置开始长度为k的子串  不翻转 变成b串j位置开始长度为k的子串 需要的步数

dp[k][i][j][1]代表a串i位置开始长度为k的子串  翻转 变成b串j位置开始长度为k的子串 需要的步数

 int n = a.size();
        memset(dp, 0x3f, sizeof(dp));
        for(int j = 0; j <= n; j++)
            for(int k = 0; k <= n; k++)
                dp[0][j][k][0] = dp[0][j][k][1] = 0;
        for(int i = 1; i <= n; i++)
            for(int j = 0; j + i <= n; j++)
                for(int k = 0; k + i <= n; k++) {
                    if(a[j] == b[k]) {
                        dp[i][j][k][0] = min(dp[i][j][k][0], dp[i - 1][j + 1][k + 1][0]);
                    }
                    if(a[j + i - 1] == b[k + i - 1]) {
                        dp[i][j][k][0] = min(dp[i][j][k][0], dp[i - 1][j][k][0]);
                    }
                    if(a[j] == b[k + i - 1]) {
                        dp[i][j][k][1] = min(dp[i][j][k][1], dp[i - 1][j + 1][k][1]);
                    }
                    if(a[j + i - 1] == b[k]) {
                        dp[i][j][k][1] = min(dp[i][j][k][1], dp[i - 1][j][k + 1][1]);
                    }
                    dp[i][j][k][0] = min(dp[i][j][k][0], dp[i][j][k][1] + 1);
                    dp[i][j][k][1] = min(dp[i][j][k][1], dp[i][j][k][0] + 1);
            }
        return dp[n][0][0][0] >= 1000 ? -1: dp[n][0][0][0];

1000

这题公式很简单

n*(1/n+1/(n - 1) + 1/ (n - 2) +...+ 1/(n - k + 1) )

关键问题来了

n ,k都巨大

然后发现这个是个调和级数求和

数字大的时候只有近似公式

那么试试呗

(1/n+1/(n - 1) + 1/ (n - 2) +...+ 1/(n - k + 1) ) 约等于  log(n + 1) + R

R是欧拉常数

完了k大的时候就用这个公式去搞。不然直接for了

但是wa出翔了

最后发现别人这么干的   本来求出来的公式是log((n + 1) / (n - k + 1))

然后有个函数叫log1p ，是干什么的呢  log1p(x)返回的就是log(x + 1)

但是问题来了，当x巨小的时候,log1p的精度比较高，用log的时候x+1就丢精度了

然后就凑呗，凑着用log1p还不行，分母减个0.5，就是用来调控精度的。

这给我蛋疼的。

完了发现房里好多不用log1p的， 我全给cha掉了

 double expectedBuy(string n, string k)
    {
        long long x = gao(n);
        long long y = gao(k);
        double ans = 0;
        long long s = x - y + 1;
        long long mx = 10000000;
        while(s <= mx) {
            ans += 1.0 / s;
            if(s == x) return x * ans;
            s++;
        }
        ans += log1p((double)(x - s + 1) / (s - 0.5));

        return ans * x;
    }