NOIP模拟测试21

Problem A:折纸

为了好做一点，直接钦定往左折，折完如果非法就调整一下（

可以开一个坐标数组记录每个点折叠后的坐标zzz 60pts

然后发现边界只有可能是处理过的点，就不用每个点都记了，只记处理过的点就行了，100pts

#include <bits/stdc++.h>

int m;
long long n;
long long sega[3005];

signed main() {
    scanf("%lld%d", &n, &m);
    long long l = 0, r = n;
    for (int i = 1; i <= m; i++) {
        scanf("%lld", &sega[i]);
        for (int j = 1; j <= i - 1; j++) {
            if (sega[j] < sega[i])
                sega[i] = 2 * sega[j] - sega[i];
        }
        l = std::min(l, 2 * sega[i] - r), r = sega[i];
        if (l > r) std::swap(l, r);
    }
    printf("%lld\n", r - l);
    return 0;
}

Problem B:不等式

当没有%M我们裆燃会做啦

$L \le Sx \le R$ 用L求个x，判断Sx是否小于R。

当拓展到%M，我们改写一下:$L \le Sx - My \le R$.

移项乱搞后：$-R \mod S \le My \le -L \mod S$

可以继续递归下去（

再把边界搞一下就vans了

#include <bits/stdc++.h>
#define bu_kai_long return
#define long_jian_zu_zong 0

int T;
long long m, s, l, r;

long long solve(long long m, long long s, long long l, long long r) {
    if (l >= m || l > r) return -1;
    if (l == 0) return 0;
    s %= m;
    if (s == 0) return -1;
    long long ans = (l - 1) / s + 1;
    if (ans * s <= r && ans * s < m) return ans;
    long long L = (-r % s + s) % s, R = (-l % s + s) % s;
    long long misaka = solve(s, m, L, R);
    if (misaka == -1) return -1;
    long long mikoto = (l + m * misaka - 1) / s + 1;
    if (s * mikoto - m * misaka <= r) return mikoto;
    return -1;
}

signed main() {
    scanf("%d", &T);
    while (T--) {
        scanf("%lld%lld%lld%lld", &m, &s, &l, &r);
        if (r >= m) r = m - 1;
        printf("%lld\n", solve(m, s, l, r));
    }
    bu_kai_long long_jian_zu_zong;
}

Problem C:reverse

 是我写不出来的数位DP：）

考场40分性价比还是很高的（

正解：设f[i][j][op1][op2]表示前i位，当前后缀长度为j，前缀reverse后与L比较的结果和比R比较的结果

这没啥说的，记搜就vans了

#include <bits/stdc++.h>
#define ull unsigned long long

int T, a, b;
ull l, r;

namespace subtask1 {
    void QAQ() {
        printf("%llu\n", r);
    }
}

namespace subtask3 {
    int A[23], B[23], C[23];
    ull f[23][23][4][4];
    bool vis[23][23][4][4];

    int cmp(int x, int y, int las) {
        if (x < y) return 0;
        else if (x == y) return las;
        else return 2;
    }

    ull dfs(int pos, bool lim, int len, int op1, int op2) {
        if (!pos) {
            if (len < A[0]) op1 = 0;
            if (len < B[0]) op2 = 0;
            return (op1 && op2 != 2) ? 1 : 0;
        } 
        if (!lim && vis[pos][len][op1][op2]) return f[pos][len][op1][op2];
        int upp = lim ? C[pos] : 9;
        ull ans = 0;
        for (int i = 0; i <= upp; i++) {
            ans += dfs(pos - 1, lim && i == upp, 
                    len + 1, cmp(i, A[len + 1], op1), cmp(i, B[len + 1], op2));
        }
        if (!lim) {
            vis[pos][len][op1][op2] = 1;
            f[pos][len][op1][op2] = ans;
        }
        return ans;
    }

    void seprate(ull x, int dig[]) {
        dig[0] = 0;
        while (x)
            dig[++dig[0]] = x % 10, x /= 10;
    }

    ull yukari() {
        memset(vis, 0, sizeof(vis));
        memset(f, 0, sizeof(f));
        ull ret = 0;
        for (int i = 1; i <= C[0]; i++) {
            int upp = i == C[0] ? C[C[0]] : 9;
            for (int j = 1; j <= upp; j++) {
                ret += dfs(i - 1, j == upp && i == C[0], 
                        1, cmp(j, A[1], 1), cmp(j, B[1], 1));    
            }
        }
        return ret;
    }

    void QAQ() {
        memset(A, 0, sizeof(A));
        memset(B, 0, sizeof(B));
        memset(C, 0, sizeof(C));
        seprate(l, A), seprate(r, B), seprate(r, C);
        ull ans = yukari();
        memset(C, 0, sizeof(C));
        seprate(l - 1, C);
        ans -= yukari();
        printf("%llu\n", ans);
    }
}

signed main() {
    scanf("%d%d%d", &T, &a, &b);
    while (T--) {
        scanf("%llu%llu", &l, &r);
        if (a && b) subtask1::QAQ();
        else subtask3::QAQ();
    }
    return 0;
}