NOIP模拟测试14

以前的坑，填一下。

写在前面的：以后我的考试感想将主要写自己的反思，题解之类的就略写了，主要能让我自己回忆起来就行。

想看详细题解点这里 https://www.cnblogs.com/Gkeng，比我写的不知高到哪里去了。

Problem A:旋转子段

一对点反转后可以成为固定点，满足$a_i + i = a_j + j$.$a_i + i$可以确定一个反转区间的中心。

我们把每个$a_i + i$扔到桶里，这里用vector。枚举区间中心，按区间长度把每个桶内排序，扫一遍用区间内固定点个数更新答案。

这题没啥问题，实名谴责出题人假数据范围。

#include <bits/stdc++.h>

const int N = 1000005;
int n, ori[N << 2], ans, sum[N << 2], pos;
std::vector<int> v[N << 2];

bool cmp(int x, int y) {
    return abs(pos - (x << 1)) < abs(pos - (y << 1));
}

signed main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &ori[i]);
        sum[i] = sum[i - 1] + (ori[i] == i);
        v[i + ori[i]].push_back(i);
    }
    for (int i = 2; i <= (n << 1); i++) {
        if (v[i].empty()) continue;
        pos = i;
        std::sort(v[i].begin(), v[i].end(), cmp);
        int j = 1;
        for (auto k : v[i]) {
            int l = k, r = i - k;
            if (l > r) std::swap(l, r);
            ans = std::max(ans, sum[l - 1] + sum[n] - sum[r] + j), j++;
        }
    }
    return !printf("%d\n", ans);
}

Problem B:走格子

初看以为就是BFS，发现限制很多。

Portal可以直接等价于跑到离得最近的墙，建立Portal，就可以前往四个方向的任意一个墙。

想到暴力建图跑最短路。预处理墙的位置更好做一点。

本次考试以及OI生涯最大失误：把数据生成器错交到了OJ上。。。。。

我都不知道我的脑子里都在想点啥。。。。。。。。

以后提交之前必须check一下，100分白丢太痛苦，Rank 2 -> Rank 35

#include <bits/stdc++.h>
#define id(x, y) ((x - 1) * m + y)

const int N = 500005, M = 505;
int n, m, ecnt, head[N], st, ed, step[M][M], dis[N];
int wall_l[M][M], wall_r[M][M], wall_u[M][M], wall_d[M][M];
const int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
char matrix[M][M];
struct Edge {int to, nxt, val;} e[N << 3];
std::queue<std::pair<int, int> > q;
bool vis[N];

inline void addedge(int f, int to, int val) {
    e[++ecnt] = {to, head[f], val}, head[f] = ecnt;
}

void link(int x, int y) {
    if (matrix[x][y] != '.') return;
    if (matrix[x][y + 1] == '.') addedge(id(x, y), id(x, y + 1), 1), 
        addedge(id(x, y + 1), id(x, y), 1);;
    if (matrix[x + 1][y] == '.') addedge(id(x, y), id(x + 1, y), 1),
        addedge(id(x + 1, y), id(x, y), 1);
    if (wall_l[x][y] != id(x, y)) addedge(id(x, y), wall_l[x][y], step[x][y]);
    if (wall_r[x][y] != id(x, y)) addedge(id(x, y), wall_r[x][y], step[x][y]);
    if (wall_u[x][y] != id(x, y)) addedge(id(x, y), wall_u[x][y], step[x][y]);
    if (wall_d[x][y] != id(x, y)) addedge(id(x, y), wall_d[x][y], step[x][y]);
}

void Dij() {
    memset(dis, 0x3f, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    std::priority_queue<std::pair<int, int> > que;
    dis[st] = 0;
    que.push(std::make_pair(0, st));
    while (!que.empty()) {
        int x = que.top().second;
        que.pop();
        if (vis[x]) continue;
        vis[x] = 1;
        for (int i = head[x], y = e[i].to; i; i = e[i].nxt, y = e[i].to) {
            if (dis[y] > dis[x] + e[i].val) {
                dis[y] = dis[x] + e[i].val;
                if (!vis[y]) que.push(std::make_pair(-dis[y], y));
            }
        }
    }
}

signed main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%s", matrix[i] + 1);
        for (int j = 1; j <= m; j++) {
            if (matrix[i][j] == 'C') matrix[i][j] = '.', st = id(i, j);
            else if (matrix[i][j] == 'F') matrix[i][j] = '.', ed = id(i, j);
            else if (matrix[i][j] == '#') q.push(std::make_pair(i, j));
        }
    }
    
    while (!q.empty()) {
        int x = q.front().first, y = q.front().second;
        q.pop();
        for (int i = 0; i <= 3; i++) {
            int xx = x + dx[i], yy = y + dy[i];
            if (matrix[xx][yy] == '.' && !step[xx][yy]) {
                step[xx][yy] = step[x][y] + 1;
                q.push(std::make_pair(xx, yy));
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (matrix[i][j] != '.') continue;
            if (matrix[i][j - 1] == '#') wall_l[i][j] = id(i, j);
            else wall_l[i][j] = wall_l[i][j - 1];
            if (matrix[i - 1][j] == '#') wall_u[i][j] = id(i, j);
            else wall_u[i][j] = wall_u[i - 1][j];
        }
    }
    
    for (int i = n; i >= 1; i--) {
        for (int j = m; j >= 1; j--) {
            if (matrix[i][j] != '.') continue;
            if (matrix[i][j + 1] == '#') wall_r[i][j] = id(i, j);
            else wall_r[i][j] = wall_r[i][j + 1];
            if (matrix[i + 1][j] == '#') wall_d[i][j] = id(i, j);
            else wall_d[i][j] = wall_d[i + 1][j];
        }
    }

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) link(i, j);

    Dij();
    if (dis[ed] == 0x3f3f3f3f) puts("no");
    else printf("%d\n", dis[ed]);
    return 0;
}

Problem C:柱状图

$O(N^3)$暴力很好想，枚举位置，枚举高度，暴力计算，考场时间剩太少&贪正解，甚至这玩意都没打。

$O(N^2)$需要动动脑子：我们要得到一个等差数列，可以直接给每一项减掉一个等差数列，再把它填平。可以想到填到处理后的中位数是最优的。

它过不去。瓶颈在于答案的计算。可以去打那个树状数组的正解，把内层的N优化到log，我直接用退火优化掉了外层的N，优化到O(玄学)。

一些人对退火有争议，我无法理解。用退火也没有什么问题，它和三分二分一样都是优化复杂度的工具，不存在什么骗AC的事情。而且本题答案(你原来要二分的那个东西，不是退火退的那个东西)必定单谷，这势必保证了退火实际效率能够吊打正解。

爱说啥说啥吧，hhh。

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

const double eps = 0.1;
const int N = 100005;
int n;
ll x[N], tmp[N], tmppos, nowpos, tmpans, nowans = 0x3f3f3f3f3f3f3f3f;
double T = 100000;

ll calc(int pos) {
    ll mx = std::max(n - pos, pos - 1);
    for (int i = 1; i <= n; i++) 
        tmp[i] = x[i] - mx + abs(i - pos);
    int mid = (1 + n) >> 1;
    ll ret = 0, mdzz = 0;
    std::nth_element(tmp + 1, tmp + mid, tmp + n + 1);
    mdzz = tmp[mid] > 0 ? tmp[mid] : 1;
    for (int i = 1; i <= n; i++) 
        ret += abs(mdzz - tmp[i]);
    return ret;
}

signed main() {
    srand(clock() + time(0));
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%lld", &x[i]);
    while (T > eps) {
        tmppos = ((int) (nowpos + (int) (T * ((double) rand()/ (double) RAND_MAX) * (rand() % 2 ? 1 : -1)) % n + n)) % n + 1;
        tmpans = calc(tmppos);
        ll delta = tmpans - nowans;
        if (delta < 0) 
             nowans = tmpans, nowpos = tmppos;
        else if (exp((double) -delta / T) * RAND_MAX > rand())
            nowpos = tmppos;
        T *= 0.976;
    }
    printf("%lld\n", nowans);
    return 0;
}