NOIP模拟测试13

C题 60分扔扔扔，太遗憾了：（

Problem A:矩阵游戏

啥也不说了，先打了个40暴力。

然后看到数据范围，想到肯定可以颓柿子。开始颓颓颓。

一个点$(i, j)$的数字是$(i - 1)m + j$。最后的答案是$\sum \limits_{i=1}^n \sum \limits_{j=1}^m R_i S_j [(i-1)m + j]$.

继续化简：

原式 = $\sum \limits_{i=1}^n R_i \sum \limits_{j=1}^m S_j [(i-1)m + j]$ = $\sum \limits_{i=1}^n R_i  ((i-1) \sum \limits_{j=1}^m mS_j + \sum \limits_{j=1}^m jS_j)$

$\sum \limits_{j=1}^m mS_j $ 和 $ \sum \limits_{j=1}^m jS_j$都可以$O(m)$线性求，最后再$O(n)$把答案求出来，得到一个$O(n + m)$的吼算法。

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

const int N = 1000000 + 233, MOD = 1000000007;
ll n, m, k, R[N], S[N], sum_s1, sum_s2, ans;

signed main() {
    scanf("%lld%lld%lld", &n, &m, &k);
    for (int i = 1; i <= n; i++) R[i] = 1ll;
    for (int i = 1; i <= m; i++) S[i] = 1ll;
    for (int i = 1; i <= k; i++) {
        char op[10]; ll x, y;
        scanf("%s%lld%lld", op, &x, &y);
        if (op[0] == 'R') {
            (R[x] *= y) %= MOD;
        } else {
            (S[x] *= y) %= MOD;
        }
    } 
    for (int i = 1; i <= m; i++) {
        sum_s1 = (sum_s1 + i * S[i]) % MOD;
        sum_s2 = (sum_s2 + m * S[i]) % MOD;
    }
    for (int i = 1; i <= n; i++) {
        ans = (ans + R[i] * ((sum_s1 + ((ll) i - 1ll) * sum_s2) % MOD) % MOD) % MOD;
    }
    return !printf("%lld\n", ans);
}

 Problem B:跳房子

考试的时候直接码了个一步一步挪的暴力。

其实看出来有循环节了，但写起来细节太多，真心码不动Orz

TKJ的这种方法很易于理解，而且很好码。

我们只看每一列，每次移动等价于一次置换。

开个线段树去维护置换，把区间+重载一下更方便。

其他部分都按普通线段树写就行。

#include <bits/stdc++.h>

const int N = 2005;
int n, m, q, val[N][N], x = 1, y = 1;

class SegTree {
private:
    struct Node {
        int nxt[N];
        friend Node operator *(Node a, Node b) {
            Node ret;
            for (int i = 1; i <= n; i++)
                ret.nxt[i] = b.nxt[a.nxt[i]];
            return ret;
        }
    } t[N << 2];
    void build(int p, int l, int r) {
        if (l == r) {
            for (int i = 1; i <= n; i++) {
                int yy = l == m ? 1 : l + 1;
                int x_1 = i == n ? 1 : i + 1;
                int x_2 = i == 1 ? n : i - 1;
                int x_3 = i;
                t[p].nxt[i] = val[x_1][yy] > val[x_2][yy] &&
                    val[x_1][yy] > val[x_3][yy] ? x_1 :
                    val[x_2][yy] > val[x_3][yy] ? x_2 : x_3;
            }
            return;
        }
        int mid = (l + r) >> 1;
        build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
        t[p] = t[p << 1] * t[p << 1 | 1];
    }
    void _change(int p, int l, int r, int x) {
        if (l == r) {
            for (int i = 1; i <= n; i++) {
                int yy = l == m ? 1 : l + 1;
                int x_1 = i == n ? 1 : i + 1;
                int x_2 = i == 1 ? n : i - 1;
                int x_3 = i;
                t[p].nxt[i] = val[x_1][yy] > val[x_2][yy] &&
                    val[x_1][yy] > val[x_3][yy] ? x_1 :
                    val[x_2][yy] > val[x_3][yy] ? x_2 : x_3;
            }
            return;
        } 
        int mid = (l + r) >> 1;
        if (x <= mid) _change(p << 1, l, mid, x);
        else _change(p << 1 | 1, mid + 1, r, x);
        t[p] = t[p << 1] * t[p << 1 | 1];
    }
    Node _query(int p, int l, int r, int L, int R) {
        if (l == L && r == R) return t[p];
        int mid = (L + R) >> 1;
        if (r <= mid) return _query(p << 1, l, r, L, mid);
        else if (l > mid) return _query(p << 1 | 1, l, r, mid + 1, R);
        else return _query(p << 1, l, mid, L, mid) * 
            _query(p << 1 | 1, mid + 1, r, mid + 1, R);
    }
    Node _qpow(Node x, int b) {
        Node ret;
        for (int i = 1; i <= n; i++) ret.nxt[i] = i;
        for (; b; b >>= 1, x = x * x)
            if (b & 1) ret = ret * x;
        return ret;
    }
public:
    SegTree() {
        build(1, 1, m);
    }
    Node query(int l, int r) {
        return _query(1, l, r, 1, m);
    }
    void change(int x) {
        _change(1, 1, m, x);
    }
    Node qpow(int b) {
        return _qpow(t[1], b);
    }
};

signed main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            scanf("%d", &val[i][j]);
    static SegTree *Gekoo = new SegTree();
    scanf("%d", &q);
    for (int i = 1; i <= q; i++) {
        char op[10]; int k, a, b, e;
        scanf("%s", op);
        if (op[0] == 'm') {
            scanf("%d", &k);
            if (!k) {
                printf("%d %d\n", x, y);
                continue;
            }
            if (y + k - 1 <= m) {
                x = Gekoo->query(y, y + k - 1).nxt[x];
                y = (y + k - 1 == m) ? 1 : y + k;
            } else {
                k -= m - y + 1;
                x = Gekoo->query(y, m).nxt[x], y = 1;
                if (k / m)
                    x = Gekoo->qpow(k / m).nxt[x];
                if (k % m)
                    x = Gekoo->query(y, y + k % m - 1).nxt[x], 
                      y += k % m;
            }
            printf("%d %d\n", x, y);
        } else {
            scanf("%d%d%d", &a, &b, &e);
            val[a][b] = e;
            Gekoo->change(b == 1 ? m : b - 1);
        }
    }
    return 0;
}

Problem C:优美序列

这题很像奇袭，一个区间是优美的，等价于$r - l = max_{[l, r]} - min_{[l, r]}$.

可以用ST表暴力做：查询出询问区间的max和min，把它们作为端点继续查，直到不再改变，可以得84pt，不详谈，直接贴代码。

#include <bits/stdc++.h>

const int N = 100005;
int n, m, pos[N], ori[N]; 
int posmn[N][20], posmx[N][20], orimn[N][20], orimx[N][20], lg[N];

inline int read() {
    int a = 0; char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
    return a;
}

inline int query_orimx(int l, int r) {
    int t = lg[r - l + 1];
    return std::max(orimx[l][t], orimx[r-(1<<t)+1][t]);
}

inline int query_orimn(int l, int r) {
    int t = lg[r - l + 1];
    return std::min(orimn[l][t], orimn[r-(1<<t)+1][t]);
}

inline int query_posmx(int l, int r) {
    int t = lg[r - l + 1];
    return std::max(posmx[l][t], posmx[r-(1<<t)+1][t]);
}

inline int query_posmn(int l, int r) {
    int t = lg[r - l + 1];
    return std::min(posmn[l][t], posmn[r-(1<<t)+1][t]);
}

signed main() {
    n = read();
    for (int i = 1; i <= n; i++) {
        scanf("%d", ori + i);
        pos[ori[i]] = i;
    }
    for (int i =  1; i <= n; i++)
        posmx[i][0] = posmn[i][0] = pos[i],
        orimx[i][0] = orimn[i][0] = ori[i];
    for (register int j = 1; (1 << j) <= n; j++)
        for (register int i = 1; i <= n - (1 << j) + 1; i++)
            posmx[i][j] = std::max(posmx[i][j-1], posmx[i+(1<<(j-1))][j-1]),
            posmn[i][j] = std::min(posmn[i][j-1], posmn[i+(1<<(j-1))][j-1]),
            orimx[i][j] = std::max(orimx[i][j-1], orimx[i+(1<<(j-1))][j-1]),
            orimn[i][j] = std::min(orimn[i][j-1], orimn[i+(1<<(j-1))][j-1]);
    for (int i = 0, t = 0; i <= n; i++) {
        if (i >= (1 << (t + 1))) t++;
        lg[i] = t;
    }
    m = read();
    while (m--) {
        int l, r, pl = 0, pr = 0, omx, omn;
        l = read(), r = read();
        bool flg = 0;
        while (l != pl || r != pr) {
            if (flg) l = pl, r = pr;
            omx = query_orimx(l, r), omn = query_orimn(l, r);
            pl = query_posmn(omn, omx), pr = query_posmx(omn, omx);
            flg = 1;
        }
        printf("%d %d\n", pl, pr);
    }
    return 0;
}

正解是分治，不提了，这里写的是DKY的线段树优化建图方法。

由上式，相邻两个数i, i + 1可以加入优美区间，仅当区间中出现了$[val_i, val_{i + 1}]$的所有值。

用边连接节点，表示限制关系，用点向区间连边显然可以线段树优化。

Tarjan缩点求SCC，DFS求出存在每个点所需要的区间。

用线段树可以维护。原因不说了，显然。

最后的答案就是区间内所有点对应区间的并。

#include <bits/stdc++.h>

const int INF = 0x3f3f3f3f, N = 400000 + 233;
int pos[N], n, val[N], m;
std::vector<int> G1[N], G2[N];
bool vis[N];

struct Node {
    int l, r;
    Node() {l = INF, r = -1;}
    Node(int ll, int rr) {l = ll, r = rr;}
    friend Node operator +(Node x, Node y) {
        return Node(std::min(x.l, y.l), std::max(x.r, y.r));    
    }
};

class SegTree {
private:
    struct Tree {
        Node t[N];
        void _change(int p, int L, int R, int x, Node v) {
            if (L == R) return (void) (t[p] = v);
            int mid = (L + R) >> 1;
            if (x <= mid) _change(p << 1, L, mid, x, v);
            else _change(p << 1 | 1, mid + 1, R, x, v);
            t[p] = t[p<<1] + t[p<<1|1];
        }
        Node _query(int p, int L, int R, int l, int r) {
            if (l <= L && r >= R) return t[p];
            int mid = (L + R) >> 1;
            if (r <= mid) return _query(p << 1, L, mid, l, r);
            else if (l > mid) return _query(p << 1 | 1, mid + 1, R, l, r);
            else return _query(p << 1, L, mid, l, mid) +
                _query(p << 1 | 1, mid + 1, R, mid + 1, r);
        }
    } seg[2];
    void _build(int p, int L, int R) {
        if (L == R) return (void) (pos[L] = p);
        int mid = (L + R) >> 1;
        _build(p << 1, L, mid), _build(p << 1 | 1, mid + 1, R);
        G1[p].push_back(p << 1), G1[p].push_back(p << 1 | 1);
    }
    void _addedge(int p, int L, int R, int l, int r, int q) {
        if (l <= L && r >= R) return (void) (G1[q].push_back(p));
        int mid = (L + R) >> 1;
        if (l <= mid) _addedge(p << 1, L, mid, l, r, q);
        if (r > mid) _addedge(p << 1 | 1, mid + 1, R, l, r, q);
    }
public:
    SegTree() {
        _build(1, 1, n);
    }
    Node query(int id, int l, int r) {
        return seg[id]._query(1, 1, n, l, r);
    }
    void addedge(int l, int r, int q) {
        _addedge(1, 1, n, l, r, q);
    }
    void change(int id, int x, Node v) {
        seg[id]._change(1, 1, n, x, v);
    }
};

int dfn[N], low[N], stk[N], num, tp, scc[N], tot;
bool ins[N];
 
void Tarjan(int x) {
    dfn[x] = low[x] = ++num;
    ins[stk[++tp] = x] = 1;
    for (auto y : G1[x]) {
        if (!dfn[y]) {
            Tarjan(y);
            low[x] = std::min(low[x], low[y]);
        } else if (ins[y]) 
            low[x] = std::min(low[x], dfn[y]);
    }
    if (low[x] == dfn[x]) {
        int y; ++tot;
        do {
            ins[y = stk[tp--]] = 0, scc[y] = tot;
        } while (x != y);
    }
}

Node t1[N], t2[N];

void dfs(int x) {
    if (vis[x]) return;
    vis[x] = 1;
    for (auto y : G2[x]) {
        dfs(y);
        t2[x] = t2[x] + t2[y]; 
    }
}

signed main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &val[i]);
    static SegTree *Gekoo = new SegTree();
    for (int i = 1; i <= n; i++)
        Gekoo->change(0, val[i], {i, i});
    for (int i = 2; i <= n; i++) {
        int l = std::min(val[i - 1], val[i]), r = std::max(val[i - 1], val[i]);
        t1[pos[i]] = Gekoo->query(0, l, r);
        Gekoo->addedge(t1[pos[i]].l + 1, t1[pos[i]].r, pos[i]);
    }
    for (int i = 1; i < N; i++)
        if (!dfn[i]) Tarjan(i);
    for (int x = 1; x < N; x++)
        for (auto y : G1[x])
            if (scc[x] != scc[y]) G2[scc[x]].push_back(scc[y]);
    for (int i = 1; i < N; i++)
        t2[scc[i]] = t2[scc[i]] + t1[i];
    for (int i = 1; i <= tot; i++) dfs(i);
    for (int i = 2; i <= n; i++)
        Gekoo->change(1, i, t2[scc[pos[i]]]);
    scanf("%d", &m);
    for (int i = 1, x, y; i <= m; i++) {
        scanf("%d%d", &x, &y);
        if (x == y) {
            printf("%d %d\n", x, y);
        } else {
            Node ans = Gekoo->query(1, x + 1, y);
            printf("%d %d\n", ans.l, ans.r);
        }
    }
    return 0;    
}