2018.09.15模拟总结（T1，T3）

过了一周，终于迎来了第二次模拟（这不是期待的语气），看第一周毒瘤程度，我就觉得接下来的模拟只能更毒瘤。

 

花了10多分钟读完了三道题，觉得暴力还是挺好写的，然后在每一道题都思索那么几分钟后，觉得还是写暴力靠谱一些……不过还好，一个半点就把暴力都写完了。

然后我就接着想正解……

T1 game

　　这道题刚开始就觉得是二维线段树，然后瞟了一眼数据范围：1e6 * 1e6，于是就犹豫了。就一直在想能不能行和列各只开一个线段树，最终反正是没想出来，于是开始优化我的暴力。推了半天发现了一个惊天秘密：就是修改的顺序是可以颠倒的：于是我就先O(n)处理了所有行的修改，然后对于所有列的修改，再暴力的O(n2)修改：所以说，只要这个数据行的修改越多，我就越容易拿掉80的点……后来经过【地表最强】lsy的山寨数据测了一下，发现还是稳稳的40分……

　　暴力以及考场心路历程就说到这吧，该讲讲正解是啥咧。

　　嗯……概括一下，就是这题没A就是数列没学好。

　　我们开一个lzy_rol[n], lzy_lin[m]两个标记数组，记录每一行或是每一列要乘上多少。假设我们没有列的操作，那么一列看成一个数，整张图就是一个长度为m的等差数列，不想O(1)的话O(m)就能求出来。现在加上了列的操作。其实就是对于每一个数ai乘上了一个lzy_lin[i]，只要按顺序算到ai,然后答案加上ai * lzy_lin[i]就行了…………

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const ll mod = 1e9 + 7;
const int maxn = 1e6 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m, q; 
char c[5];
ll lzy_rol[maxn], lzy_lin[maxn]; 
ll s = 0, d = 0, sum = 0;

ll getnum(int x, int i)
{
    return ((ll)(i - 1) * m + x) % mod;
}

int main()
{
    freopen("game.in", "r", stdin);
    freopen("game.out", "w", stdout);
    n = read(); m = read(); q = read();
    for(int i = 1; i < maxn; ++i) lzy_rol[i] = lzy_lin[i] = 1;
    for(int i = 1; i <= q; ++i)
    {
        scanf("%s", c); int x = read(); ll k = read();
        if(c[0] == 'R') lzy_rol[x] *= k, lzy_rol[x] %= mod;    
        else lzy_lin[x] *= k, lzy_lin[x] %= mod;
    }
    for(int i = 1; i <= n; ++i)
    {
        s += getnum(1, i) * lzy_rol[i]; s %= mod;
        d += lzy_rol[i]; d %= mod;
    }                            //s:首项，d:公差 
    for(rg int i = 1; i <= m; ++i)        
    {
        sum += lzy_lin[i] * s; sum %= mod;
        s += d; s %= mod;
    }
    write(sum); enter;
    return 0;
}

T2 jump

　　在考场上我第一反应就是20分暴力，然后chuachuachua15分钟就写完了。于是就直接去搞第三题的暴力了。

　　第三题暴力写完后又回来看这道题，然后就想到了一个50分的想法：先求出一个跳房子的周期，然后移动每一次k步，只要对周期取模即可。至于修改，那就是暴利修改啦。然而时间不是很够，于是就没写完。

　　至于正解，我到现在还不是很懂。学姐写的是线段树维护置换。然后正解是一个很奇特的算法，不过这俩都没听懂……据说路由器还有一个更简单的做法，然而没人跟我讲啊……

T3 sequence

　　我上文已经说过了，当时也是写的暴利。而且还没想到比较正常的O(n²)暴利，自己搞了一个很奇葩的算法：就是先预处理每一个数出现的位置，然后统计当前查询区间没出现的数，然后利用这些数字不断扩大查询区间，直到区间最大值减最小值等于区间长度为止。

　　正解其实跟我的暴利有点像：要维护两个线段树：第一个是区间最值，第二个是在值域区间中出现位置的最值（所以说，RMQ其实就行了，而且常数更小）。

　　然后我们要递归的查询：先在询问区间[L, R]中查询最小最大值Min, Max.然后在第二个线段树的区间[Min, Max]中查询出现位置的最值Minl, Minr，再换到第一个线段树在[Minl, Minr]中查询数的最大最小值……直到Max - Min = R - L，这时候的L, R 就是答案。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e5 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m, a[maxn];

struct Tree
{
    int a[maxn];
    int l[maxn << 2], r[maxn << 2], Min[maxn << 2], Max[maxn << 2];
    Tree()
    {
        Mem(a, 0);
        Mem(l, 0); Mem(r, 0);
        Mem(Min, 0); Mem(Max, 0);
    }
    void build(int L, int R, int now)
    {
        l[now] = L; r[now] = R;
        if(L == R) {Min[now] = Max[now] = a[L]; return;}
        int mid = (L + R) >> 1;
        build(L, mid, now << 1);
        build(mid + 1, R, now << 1 | 1);
        Min[now] = min(Min[now << 1], Min[now << 1 | 1]);
        Max[now] = max(Max[now << 1], Max[now << 1 | 1]);        
    }
    int query(int L, int R, int now, bool flg)
    {
        if(L == l[now] && R == r[now]) return flg ? Max[now] : Min[now];
        int mid = (l[now] + r[now]) >> 1;
        if(R <= mid) return query(L, R, now << 1, flg);
        else if(L > mid) return query(L, R, now << 1 | 1, flg);
        else 
        {
            int ret;
            if(flg) ret = max(query(L, mid, now << 1, flg), query(mid + 1, R, now << 1 | 1, flg));
            else ret = min(query(L, mid, now << 1, flg), query(mid + 1, R, now << 1 | 1, flg));
            return ret;
        }
    }
}Seq, Num;

#define pr pair<int, int>
#define mp make_pair 
#define fir first
#define sec second
pr Query(int L, int R)
{
    while(1)
    {
        int Ml = Seq.query(L, R, 1, 0), Mr = Seq.query(L, R, 1, 1);
        if(Mr - Ml == R - L) return mp(L, R);
        L = Num.query(Ml, Mr, 1, 0);
        R = Num.query(Ml, Mr, 1, 1);
    }
}

int main()
{
    freopen("sequence.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
    n = read();
    for(int i = 1; i <= n; ++i) a[i] = read();
    for(int i = 1; i <= n; ++i) Seq.a[i] = a[i], Num.a[a[i]] = i;
    Seq.build(1, n, 1); Num.build(1, n, 1); 
    m = read();
    for(int i = 1; i <= m; ++i)
    {
        int L = read(), R = read();
        pr p = Query(L, R);
        write(p.fir); space; write(p.sec); enter;
    }
    return 0;
}

不过这个线段树好像常数很大，然后换了数据后后面几个点就TLE了……那真正的正解就不太懂了。

　　总的来说今天的考试还是挺顺利的，暴利一个半点很愉快的就写完了。自己估分100左右，结果出成绩后刚好102，顿时觉得自己相当nb。反正想拿的分都拿到了，就没什么遗憾。