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-;
 const ll mod = 1e9 + ;
 const int maxn = 1e6 + ;
 inline ll read()
 {
     ll ans = ;
     char ch = getchar(), last = ' ';
     while(!isdigit(ch)) {last = ch; ch = getchar();}
     while(isdigit(ch)) {ans = ans *  + ch - ''; ch = getchar();}
     if(last == '-') ans = -ans;
     return ans;
 }
 inline void write(ll x)
 {
     if(x < ) x = -x, putchar('-');
     if(x >= ) write(x / );
     putchar(x %  + '');
 }

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

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

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

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-;
 const int maxn = 1e5 + ;
 inline ll read()
 {
     ll ans = ;
     char ch = getchar(), last = ' ';
     while(!isdigit(ch)) {last = ch; ch = getchar();}
     while(isdigit(ch)) {ans = ans *  + ch - ''; ch = getchar();}
     if(last == '-') ans = -ans;
     return ans;
 }
 inline void write(ll x)
 {
     if(x < ) x = -x, putchar('-');
     if(x >= ) write(x / );
     putchar(x %  + '');
 }

 int n, m, a[maxn];

 struct Tree
 {
     int a[maxn];
     int l[maxn << ], r[maxn << ], Min[maxn << ], Max[maxn << ];
     Tree()
     {
         Mem(a, );
         Mem(l, ); Mem(r, );
         Mem(Min, ); Mem(Max, );
     }
     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) >> ;
         build(L, mid, now << );
         build(mid + , R, now <<  | );
         Min[now] = min(Min[now << ], Min[now <<  | ]);
         Max[now] = max(Max[now << ], Max[now <<  | ]);
     }
     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]) >> ;
         if(R <= mid) return query(L, R, now << , flg);
         else if(L > mid) return query(L, R, now <<  | , flg);
         else
         {
             int ret;
             if(flg) ret = max(query(L, mid, now << , flg), query(mid + , R, now <<  | , flg));
             else ret = min(query(L, mid, now << , flg), query(mid + , R, now <<  | , 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()
     {
         int Ml = Seq.query(L, R, , ), Mr = Seq.query(L, R, , );
         if(Mr - Ml == R - L) return mp(L, R);
         L = Num.query(Ml, Mr, , );
         R = Num.query(Ml, Mr, , );
     }
 }

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

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

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