20210823模拟赛解题报告

目录

• 写在前面
• T1
  • Solution
  • Code
• T2
  • Solution
  • Code
• T3
  • Solution
  • Code

写在前面

这套题一如既往的魔幻，值得喷的地方依旧很多。

第一题小清新思维题还好。

第二题最长公共子序列是个原题！

第三题是个爆搜大模拟，数据和题解还都是错的！

期望得分：(100pts + 60pts + 40pts = 200pts)

实际得分：(30pts + 60pts + 40pts = 130pts)

T1 答案没取模挂惨了/kk

T2 只会 (O(nm)) 做法，正解是 (O(n^2))。

T3 在洛谷上能跑到 50pts，众所周知机房机子跑的慢。

补题通道：

T1	T2	T3
U175818 road	U175823 lcs	U175820 cube

T1

Solution

简述题意就是 (n) 个点 (n) 条边，然后对无向边重定向。

对于一个环，当重定向后仍是一个环时，仅有两种情况（所有边全朝一个方向）。
如果这个环只有 (x) 个点，那么这个环一共有 (2^x - 2) 种合法方案。

不在环上的边怎么都无所谓。

可以把每个边的方向看做 01 两种情况，那么设第 (i) 个环上有 (x_i) 个边（点），一共有 (k) 个环，不在环上的边有 (y) 条，那么答案为：

[2^y imes prod_{i=1}^k (2^{x_i}-2) pmod {10^9+7} ]

至于判断环……

我不会 dfs，也没用 tarjan，写的生成树 + 树剖。

Code

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#define LL long long
#define orz cout << "lkp AK IOI!
"  
using namespace std;
const LL MAXN = 1e5 + 500;
const LL INF = 1e9 + 7;
const LL mod = 1e9 + 7;

struct edge {
    LL to, nxt;
}e[MAXN << 1], E[MAXN];
LL head[MAXN], num_edge = 1, sc = 0;

LL n, m, Cnt = 0;
LL dep[MAXN], Fa[MAXN];
LL fath[MAXN], siz[MAXN], son[MAXN], top[MAXN];
bool vis[MAXN];

LL read() {
    LL f = 0, s = 0;
    char ch = getchar();
    while(!isdigit(ch)) f = (ch == '-'), ch = getchar();
    while(isdigit(ch)) s = (s << 3) + (s << 1) + ch - '0', ch = getchar();
    return f ? -s : s;
}

LL find(LL x) { return Fa[x] == x ? x : Fa[x] = find(Fa[x]); }
void add_edge(LL from, LL to) { e[++num_edge] = (edge){to, head[from]}, head[from] = num_edge; }

void dfs(LL u, LL fa) { 
//    cout<<u<<" "<<fa<<"
";
    vis[u] = true;
    dep[u] = dep[fa] + 1, fath[u] = fa, siz[u] = 1;
    for(LL i = head[u]; i; i = e[i].nxt) {
        LL v = e[i].to;
        if(v == fa) continue;
        dfs(v, u);
        siz[u] += siz[v]; 
        if(siz[son[u]] < siz[v]) son[u] = v;
    }
}

void dfs2(LL u, LL tp) {
    top[u] = tp;
    if(son[u]) dfs2(son[u], tp);
    for(LL i = head[u]; i; i = e[i].nxt) {
        LL v = e[i].to;
        if(v == fath[u] || v == son[u]) continue;
        dfs2(v, v);
    }
} 

LL Get_LCA(LL x, LL y) {
    while(top[x] != top[y]) dep[top[x]] < dep[top[y]] ? y = fath[top[y]] : x = fath[top[x]];
    return dep[x] < dep[y] ? x : y;
}

LL Pow(LL x, LL p) {
    LL res = 1;
    while(p) {
        if(p & 1) res = res * x % mod;
        x = x * x % mod;
        p >>= 1;
    }
    return res;
}

int main() {
//    freopen("road.in","r",stdin);
//    freopen("road.out","w",stdout);
    n = read();
    for(LL i = 1; i <= n; ++i) Fa[i] = i;
    for(LL i = 1, x; i <= n; ++i) {
        x = read();
        LL uf = find(i), vf = find(x);
        if(uf != vf) {
            add_edge(i, x), add_edge(x, i);
            Fa[uf] = vf;
        } else {
            E[++sc] = (edge){i, x};
        }
    }
//    cout<<sc<<"
";
    for(LL i = 1; i <= n; ++i) {
        if(!vis[i]) {
            dfs(i, 0);
            dfs2(i, i);
        }
    }
    int Ans = 1, tot = n;
//    for(int i = 1; i <= n; ++i) cout<<dep[i]<<" "; puts("");
    for(LL i = 1; i <= sc; ++i) {
        LL u = E[i].to, v = E[i].nxt;
        if(dep[u] < dep[v]) swap(u, v);
        int lca = Get_LCA(u, v);
        LL len = dep[u] + dep[v] - 2 * dep[lca] + 1;
//        cout << u << " " << v << " " << lca<<" " << len << "
";
//        cout << dep[u]<<" "<<dep[v]<<" "<<dep[lca]<<"
"; 
        Ans = Ans * (Pow(2, len) - 2) % mod;
        tot -= len;
    }
    Ans = Ans * Pow(2, tot) % mod;
    cout << Ans << "
";
    return 0;
}
/*
5
2 3 1 5 4

8
8 1 1 2 2 3 3 7
*/

T2

Solution

一直把 T2 当场最长公共上升子序列了，淦。

考虑朴素 DP，记 (f(i,j)) 表示 (s1) 匹配到了第 (i) 位，(s2) 匹配到了第 (j) 位，的最长公共子序列长度，那么我们有如下递推关系：

[f(i,j) = max egin{cases} f(i-1,j) \ f(i,j-1) \ f(i-1,j-1)+1 & [s1_i = s2_j] end{cases} ]

该 DP 时间复杂度和空间复杂度均为 (O(leftvert s1 ightvertleftvert s2 ightvert))。

由于 (s2) 较长，考虑改变 DP 的角度。
记 (g(i,j)) 表示 (s1) 匹配到了第 (i) 位，最长公共子序列长度为 (j) 时，(s2) 可能匹配到的最左下标，那么我们有如下递推关系：

[g(i,j) = max egin{cases} g(i-1,j) \ nxt(g(i-1,j-1),s1_i) end{cases} ]

其中，(nxt(i,ch)) 表示 (s2) 第 (i) 位后第一个字母 (ch) 出现的位置。
该 DP 的时间复杂度为 (O(leftvert s1 ightvert^ 2 ))，空间复杂度为 (O(leftvert s1 ightvert^2 + leftvert s2 ightvert imes 26))。

Code

/*
Work by: Suzt_ilymics
Problem: 不知名屑题
Knowledge: 垃圾算法
Time: O(能过)
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#define LL long long
#define orz cout<<"lkp AK IOI!"<<endl

using namespace std;
const int MAXN = 1e6+500;
const int INF = 1e9+7;
const int mod = 1e9+7;

char s1[1010], s2[MAXN];
int n, m, Ans = 0;
int nxt[MAXN][27], lst[27];
int f[1010][1010];

int read(){
    int s = 0, f = 0;
    char ch = getchar();
    while(!isdigit(ch))  f |= (ch == '-'), ch = getchar();
    while(isdigit(ch)) s = (s << 1) + (s << 3) + ch - '0' , ch = getchar();
    return f ? -s : s;
}

int main()
{
    cin >> s1 + 1 >> s2 + 1;
    n = strlen(s1 + 1), m = strlen(s2 + 1);
    for(int i = 0; i < 26; ++i) lst[i] = m + 1;
    for(int i = 0; i < 26; ++i) nxt[m+1][i] = m + 1;
    for(int i = m; i >= 1; --i) {
        memcpy(nxt[i], nxt[i + 1], sizeof nxt[i]);
        nxt[i][s2[i] - 'a'] = i;
//        lst[s2[i] - 'a'] = i;
//        for(int j = 0; j < 26; ++j) {
//            nxt[i][j] = lst[j];
//        }
    }
    memset(f, 0x3f, sizeof f);
    f[1][1] = nxt[1][s1[1] - 'a'];
    for(int i = 0; i <= n; ++i) f[i][0] = 0;
    for(int i = 1; i <= n; ++i) {
        for(int j = 1; j <= n; ++j) {
            if(f[i - 1][j - 1] <= m) f[i][j] = min(f[i - 1][j], nxt[f[i - 1][j - 1] + 1][s1[i] - 'a']);
            else f[i][j] = f[i - 1][j];
            if(f[i][j] <= m) Ans = max(Ans, j);
        }
    }
    printf("%d", Ans);
    return 0;
}

T3

Solution

按照题意模拟即可，搜的时候先搜字典序小的，记录一个 (lst) 存上一次操作类型。

题解说前九操作和后九种操作一样，加上它们不会更优，所以可以不考虑。那爆搜就完了啊！

但是样例显然可以 1 16，比一个 2 更优（题目自己说的）。

所以题解的思路是错的，然后跑出来的数据也是错的。

不过值得借鉴的一点是，题解用了一个很 nb 的置换群，我不会，但码量贼短。要知道我自己考场上用一个半小时打了 8KB。

Code

代码是正确题意的代码，但是复杂度是 (O(18^7)) 还带一个常数，我没有想到怎么剪枝。

题目数据还是错的，如果想通过本题只需打前九个操作的部分即可。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<queue>
#include<vector>
#include<map>
#include<algorithm>
#define orz cout << "lkp AK IOI!
"
using namespace std;
const int MAXN = 1e5 + 500;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;

struct node {
    int c[26];
    bool operator < (const node &b) const { 
        for(int i = 1; i <= 24; ++i) {
            if(c[i] != b.c[i]) {
                return c[i] < b.c[i];
            }
        }
        return true;
     }
}base;

int n;
int stc[100], sc = 0;
map<node, bool> Map;

int read() {
    int f = 0, s = 0;
    char ch = getchar();
    while(!isdigit(ch)) f = (ch == '-'), ch = getchar();
    while(isdigit(ch)) s = (s << 3) + (s << 1) + ch - '0', ch = getchar();
    return f ? -s : s;
}

namespace Work {
    node A1(node x) {
        int res = x.c[2];
        x.c[2] = x.c[1], x.c[1] = x.c[3], x.c[3] = x.c[4], x.c[4] = res;
        int p1 = x.c[24], p2 = x.c[23];
        x.c[24] = x.c[9], x.c[23] = x.c[10];
        x.c[9] = x.c[5], x.c[10] = x.c[6];
        x.c[5] = x.c[13], x.c[6] = x.c[14];
        x.c[13] = p1, x.c[14] = p2;
        return x;
    }
    node A2(node x) { x = A1(x), x = A1(x); return x; }
    node A3(node x) { x = A1(x), x = A1(x), x = A1(x); return x; }
    node B1(node x) {
        int res = x.c[10];
        x.c[10] = x.c[9], x.c[9] = x.c[11], x.c[11] = x.c[12], x.c[12] = res;
        int p1 = x.c[1], p2 = x.c[3];
        x.c[1] = x.c[21], x.c[3] = x.c[23];
        x.c[21] = x.c[17], x.c[23] = x.c[19];
        x.c[17] = x.c[5], x.c[19] = x.c[7];
        x.c[5] = p1, x.c[7] = p2;
        return x;
    }
    node B2(node x) { x = B1(x), x = B1(x); return x; }
    node B3(node x) { x = B1(x), x = B1(x), x = B1(x); return x; }
    node C1(node x) {
        int res = x.c[5];
        x.c[5] = x.c[7], x.c[7] = x.c[8], x.c[8] = x.c[6], x.c[6] = res;
        int p1 = x.c[3], p2 = x.c[4];
        x.c[3] = x.c[12], x.c[4] = x.c[10];
        x.c[12] = x.c[18], x.c[10] = x.c[17];
        x.c[18] = x.c[13], x.c[17] = x.c[15];
        x.c[13] = p1, x.c[15] = p2;
        return x;
    }
    node C2(node x) { x = C1(x), x = C1(x); return x; }
    node C3(node x) { x = C1(x), x = C1(x), x = C1(x); return x; }
    node D1(node x) {
        int res = x.c[13];
        x.c[13] = x.c[15], x.c[15] = x.c[16], x.c[16] = x.c[14], x.c[14] = res;
        int p1 = x.c[4], p2 = x.c[2];
        x.c[4] = x.c[8], x.c[2] = x.c[6];
        x.c[8] = x.c[20], x.c[6] = x.c[18];
        x.c[20] = x.c[24], x.c[18] = x.c[22];
        x.c[24] = p1, x.c[22] = p2;
        return x;
    }
    node D2(node x) { x = D1(x), x = D1(x); return x; }
    node D3(node x) { x = D1(x), x = D1(x), x = D1(x); return x; }
    node E1(node x) {
        int res = x.c[21];
        x.c[21] = x.c[23], x.c[23] = x.c[24], x.c[24] = x.c[22], x.c[22] = res;
        int p1 = x.c[19], p2 = x.c[20];
        x.c[19] = x.c[9], x.c[20] = x.c[11];
        x.c[9] = x.c[2], x.c[11] = x.c[1];
        x.c[2] = x.c[11], x.c[1] = x.c[14];
        x.c[11] = p1, x.c[14] = p2;
        return x;
    } 
    node E2(node x) { x = E1(x), x = E1(x); return x; }
    node E3(node x) { x = E1(x), x = E1(x), x = E1(x); return x; }
    node F1(node x) {
        int res = x.c[17];
        x.c[17] = x.c[19], x.c[19] = x.c[20], x.c[20] = x.c[18], x.c[18] = res;
        int p1 = x.c[7], p2 = x.c[8];
        x.c[7] = x.c[11], x.c[8] = x.c[12];
        x.c[11] = x.c[22], x.c[12] = x.c[21];
        x.c[22] = x.c[15], x.c[21] = x.c[16];
        x.c[15] = p1, x.c[16] = p2;
        return x;
    }
    node F2(node x) { x = F1(x), x = F1(x); return x; }
    node F3(node x) { x = F1(x), x = F1(x), x = F1(x); return x; }
}
using namespace Work;

bool Check(node x) {
    for(int i = 4; i <= 24; i += 4) {
        int p = i / 4;
        if(x.c[i - 3] == x.c[i - 2] && x.c[i - 2] == x.c[i - 1] && x.c[i - 1] == x.c[i]) continue;
        return false;
    }
    return true;
}

namespace Subtask1 {
    void Solve() {
        node x = base;
        if(Check(A1(x))) puts("1");
        else if(Check(A2(x))) puts("2");
        else if(Check(A3(x))) puts("3");
        else if(Check(B1(x))) puts("4");
        else if(Check(B2(x))) puts("5");
        else if(Check(B3(x))) puts("6");
        else if(Check(C1(x))) puts("7");
        else if(Check(C2(x))) puts("8");
        else if(Check(C3(x))) puts("9");
        else if(Check(D1(x))) puts("10");
        else if(Check(D2(x))) puts("11");
        else if(Check(D3(x))) puts("12");
        else if(Check(E1(x))) puts("13");
        else if(Check(E2(x))) puts("14");
        else if(Check(E3(x))) puts("15");
        else if(Check(F1(x))) puts("16");
        else if(Check(F2(x))) puts("17");
        else if(Check(F3(x))) puts("18");
        else puts("-1");
    }
}

bool Flag = false;
void dfs(int stp, node now_, int lst) {
    // if(Map[now_]) {
    //     Map[now_] = true;
    //     return ;
    // }
    if(Check(now_)) {
       Flag = true;
       return ;
    }
    if(stp > n) return ;
    if(lst != 1 && lst != 2 && lst != 3)  { stc[++sc] = 1;  dfs(stp + 1, A1(now_), 1);  if(Flag) return ; sc--; }
    if(lst != 1 && lst != 2 && lst != 3)  { stc[++sc] = 2;  dfs(stp + 1, A2(now_), 2);  if(Flag) return ; sc--; }
    if(lst != 1 && lst != 2 && lst != 3)  { stc[++sc] = 3;  dfs(stp + 1, A3(now_), 3);  if(Flag) return ; sc--; }
    if(lst != 4 && lst != 5 && lst != 6)  { stc[++sc] = 4;  dfs(stp + 1, B1(now_), 4);  if(Flag) return ; sc--; }
    if(lst != 4 && lst != 5 && lst != 6)  { stc[++sc] = 5;  dfs(stp + 1, B2(now_), 5);  if(Flag) return ; sc--; }
    if(lst != 4 && lst != 5 && lst != 6)  { stc[++sc] = 6;  dfs(stp + 1, B3(now_), 6);  if(Flag) return ; sc--; }
//    if(n > 3) return ;
    if(lst != 7 && lst != 8 && lst != 9)  { stc[++sc] = 7;  dfs(stp + 1, C1(now_), 7);  if(Flag) return ; sc--; }
    if(lst != 7 && lst != 8 && lst != 9)  { stc[++sc] = 8;  dfs(stp + 1, C2(now_), 8);  if(Flag) return ; sc--; }
    if(lst != 7 && lst != 8 && lst != 9)  { stc[++sc] = 9;  dfs(stp + 1, C3(now_), 9);  if(Flag) return ; sc--; }
    if(lst != 10 && lst != 11 && lst != 12) { stc[++sc] = 10; dfs(stp + 1, D1(now_), 10); if(Flag) return ; sc--; }
    if(lst != 10 && lst != 11 && lst != 12) { stc[++sc] = 11; dfs(stp + 1, D2(now_), 11); if(Flag) return ; sc--; }
    if(lst != 10 && lst != 11 && lst != 12) { stc[++sc] = 12; dfs(stp + 1, D3(now_), 12); if(Flag) return ; sc--; }
    if(lst != 13 && lst != 14 && lst != 15) { stc[++sc] = 13; dfs(stp + 1, E1(now_), 13); if(Flag) return ; sc--; }
    if(lst != 13 && lst != 14 && lst != 15) { stc[++sc] = 14; dfs(stp + 1, E2(now_), 14); if(Flag) return ; sc--; }
    if(lst != 13 && lst != 14 && lst != 15) { stc[++sc] = 15; dfs(stp + 1, E3(now_), 15); if(Flag) return ; sc--; }
    if(lst != 16 && lst != 17 && lst != 18) { stc[++sc] = 16; dfs(stp + 1, F1(now_), 16); if(Flag) return ; sc--; }
    if(lst != 16 && lst != 17 && lst != 18) { stc[++sc] = 17; dfs(stp + 1, F2(now_), 17); if(Flag) return ; sc--; }
    if(lst != 16 && lst != 17 && lst != 18) { stc[++sc] = 18; dfs(stp + 1, F3(now_), 18); if(Flag) return ; sc--; }
}

int main() {
//    freopen("cube.in","r",stdin);
//    freopen("cube.out","w",stdout);
    n = read();
    for(int i = 1; i <= 24; ++i) {
        base.c[i] = read();
    }
    if(n == 1) { Subtask1::Solve(); }
    else {
        dfs(1, base, 0);
        for(int i = 1; i <= sc; ++i)  printf("%d ", stc[i]);
        puts("");
    }
    return 0;
}
/*
2
1 1 1 1
4 4 2 2
6 6 3 3 
3 3 6 6 
5 5 5 5
4 4 2 2
*/