Tsinghua 2018 DSA PA3简要题解

CST2018 3-1-1 Sum (15%)

简单的线段树，单点修改，区间求和。

很简单。

 

CST2018 3-1-2 Max (20%)

高级的线段树。

维护区间最大和，区间和，左边最大和，右边最大和。

单点修改的时候一路吧区间都改了就好了。

求子段最大值也就判断一下左右就好了。

略微复杂。

#include <cstdio>

using namespace std;
const int N = 5e5 + 5;
const int inf = 1e9;
int n, m;
int a[N];

inline int max(int x, int y) {
    return x > y ? x : y;
}

struct seg {
    seg *ls, *rs;
    int sum, mx, mxl, mxr;
    
    void* operator new(size_t) {
        static seg* c;
        c = new seg[1];
        c -> ls = c -> rs = NULL;
        c -> mxl = c -> mxr = c -> mx = c -> sum = 0;
        return c;
    }
    
    inline void change_point(int x) { //change the value of a single point
        if (x > 0) {
            sum = mx = mxl = mxr = x;
        } else {
            sum = x;
            mx = mxl = mxr = 0;
        }
    }
    
    inline void update() {
        if (ls == NULL || rs == NULL) return;
        sum = ls -> sum + rs -> sum;
        mx = max(max(ls -> mx, rs -> mx), ls -> mxr + rs -> mxl);
        mxl = max(ls -> mxl, ls -> sum + rs -> mxl);
        mxr = max(rs -> mxr, rs -> sum + ls -> mxr);
    }
    
    #define mid (l + r >> 1)
    void build(int l, int r) {
        if (l == r) {
            change_point(a[l]);
            return;
        }
        ls = new()seg, ls -> build(l, mid);
        rs = new()seg, rs -> build(mid + 1, r);
        update();
    }
    
    void modify(int l, int r, int pos, int x) {
        if (pos < l || r < pos) return;
        if (l == r) {
            change_point(x);
            return;
        }
        if (pos <= mid) ls -> modify(l, mid, pos, x);
        if (mid < pos) rs -> modify(mid + 1 , r, pos, x);
        update();
    }
    
    seg* query(int l, int r, int L, int R) {
        seg* ret = new()seg;
        if (l == L && R == r) {
            *ret = *this;
            return ret;
        }
        if (R <= mid) return ls -> query(l, mid, L, R);
        if (L > mid) return rs -> query(mid + 1, r, L, R);
        
        ret -> ls = ls -> query(l, mid, L, mid);
        ret -> rs = rs -> query(mid + 1, r, mid + 1, R);
        ret -> update();
        delete ret -> ls;
        delete ret -> rs;
        return ret;
    }
    #undef mid
} *segment, *ans;

int main() {
    int op, x, y;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)
        scanf("%d", a + i);
    segment = new()seg;
    segment -> build(1, n);    
    for (int i = 1; i <= m; ++i) {
        scanf("%d%d%d", &op, &x, &y);
        if (op == 0) {
            segment -> modify(1, n, x, y);
        } else {
            ans = segment -> query(1, n, x, y);
            printf("%d\n", ans -> mx);
            delete ans;
        }
    }
    return 0;
}

 

CST2018 3-2 Not Found (20%)

内存有点小，在考虑按层建立trie树？

不太会。

 

CST2018 3-3 Hacker (20%)

$18^5$其实并不大，直接预处理hash一下就好了。

冲突的话直接记录输出duplicate。

比较简单。

#include <cstdio>
#include <cstring>
#include "crc.h"

using namespace std;
const char charset[] = "0123456789tsinghua";
const char setlen = 18;
const int P2 = 38734667;
const char LEN = 20;
int hashTable[P2], flag[P2];

char code[LEN];
char pwd[LEN];

int n;
char salt[LEN];
int saltlen;

int test_cnt;

inline int encode_char(char ch) {
    switch(ch) {
        case '0' : return 1;
        case '1' : return 2;
        case '2' : return 3;
        case '3' : return 4;
        case '4' : return 5;
        case '5' : return 6;
        case '6' : return 7;
        case '7' : return 8;
        case '8' : return 9;
        case '9' : return 10;
        case 't' : return 11;
        case 's' : return 12;
        case 'i' : return 13;
        case 'n' : return 14;
        case 'g' : return 15;
        case 'h' : return 16;
        case 'u' : return 17;
        case 'a' : return 18;
    }
}

inline char decode_char(int x) {
    switch(x) {
        case 1 : return '0';
        case 2 : return '1';
        case 3 : return '2';
        case 4 : return '3';
        case 5 : return '4';
        case 6 : return '5';
        case 7 : return '6';
        case 8 : return '7';
        case 9 : return '8';
        case 10 : return '9';
        case 11 : return 't';
        case 12 : return 's';
        case 13 : return 'i';
        case 14 : return 'n';
        case 15 : return 'g';
        case 16 : return 'h';
        case 17 : return 'u';
        case 18 : return 'a';
    }
}

inline int encode(char* str) {
    int len = strlen(str);
    int encodeNumber = 0;
    for (int i = 0; i < len; ++i)
        encodeNumber = 19 * encodeNumber + encode_char(str[i]);
    return encodeNumber;
}

inline void swap(char &x, char &y) {
    char t;
    t = x;
    x = y;
    y = t;
}

inline void decode(char* str, int x) {
    int t = 0;
    while (x) {
        str[t] = decode_char(x % 19);
        x = x / 19;
        t += 1;
    }
    for (int i = 0; i * 2 < t; ++i) {
        swap(str[i], str[t - i - 1]);
    }
    str[t] = 0;
}

int _union(char *str, unsigned char *input) {
    int i = 0;
    for (; str[i]; ++i) input[i] = str[i];
    for (int j = 0; salt[j]; ++j) input[i++] = salt[j];
    input[i] = 0;
    return i;
}

inline bool check_eq(int x, int y) {
    char str[10];
    decode(str, x);
    unsigned char input[20];
    int i = _union(str, input);
    int CRC32Value1 = crc32(input, i);
    if (CRC32Value1 == y) return 1;
    return 0;
}

void insert_hash(int x, int y) {
    int hash = ((x % P2) + P2) % P2;
    while (hashTable[hash] != -1) {
        if (check_eq(hashTable[hash], x)) {
            flag[hash] = 1;
            return;
        }
        hash += 1;
    }
    hashTable[hash] = y;
}

void update_pwd(char x) {
    for (int i = 0; i <= 5; ++i)
        pwd[i] = pwd[i + 1];
    pwd[6] = x;
    pwd[7] = 0;
}

void get_hash(int x) {
    int hash = ((x % P2) + P2) % P2;
    while (hashTable[hash] != -1) {
        if (check_eq(hashTable[hash], x)) {
            if (flag[hash] == 1) {
                puts("duplicate");
                return;
            }
            char ans[10];
            decode(ans, hashTable[hash]);
            printf("%s\n", ans);
            update_pwd(ans[0]);
            return;
        }
        hash += 1;
    }
    puts("No");
}

void make_hash(char* str) {
    unsigned char input[20];
    int i = _union(str, input);
    int CRC32Value = crc32(input, i); //calculate CRC32
    insert_hash(CRC32Value, encode(str));
}

void dfs(int len) {
    for (int i = 0; i < setlen; ++i) {
        code[len] = charset[i];
        code[len + 1] = 0;
        make_hash(code);
        if (len < 4) dfs(len + 1);
    }
}

void find_hash() {
    int CRC32Value;
    scanf("%d", &CRC32Value);
    get_hash(CRC32Value);
}

int main() {
    int len;
    int oper;
    scanf("%d\n", &n);
    scanf("%s\n", salt);
    saltlen = strlen(salt);
    for (int i = 0; i < P2; ++i)
        hashTable[i] = -1, flag[i] = 0;
    
    dfs(0);
    while (n--) {
        scanf("%d\n", &oper);
        if (oper == 0) {
            find_hash();
        }
        if (oper == 1) {
            make_hash(pwd);
        }
    }
    return 0;
}

 

CST2018 3-4 kth (20%)

可以先通过3n次比较进行排序。

一个数组的话直接二分就好了。

要是两个数组可以丢堆里面。

三个不会【摊手

#include "kth.h"
#include <cstdio>

using namespace std;
const int N = 5e5 + 5;
const int K = 26e5 + 5;

int X[N], Y[N], Z[N];

template<class T> inline void swap(T &x, T &y) {
    register T tmp;
    tmp = x, x = y, y = tmp;
}

struct heap {
    heap *ls, *rs;
    int _X, _Y, _Z;
    int dep;
    
    void *operator new(size_t, int __X, int __Y, int __Z) {
        static heap mempool[K], *c = mempool;
        c -> ls = c -> rs = NULL;
        c -> dep = 1;
        c -> _X = __X, c -> _Y = __Y, c -> _Z = __Z;
        return c++;
    }
    
    friend inline bool compare_greater(heap *x, heap *y) {
        return compare(X[y -> _X], Y[y -> _Y], Z[y -> _Z], X[x -> _X], Y[x -> _Y], Z[x -> _Z]);
    }
    
    #define Dep(p) (p ? p -> dep : 0)
    friend heap* merge(heap *x, heap *y) {
        if (!x) return y;
        if (!y) return x;
        if (compare_greater(x, y)) swap(x, y);
        x -> rs = merge(x -> rs, y);
        if (Dep(x -> rs) > Dep(x -> ls)) swap(x -> ls, x -> rs);
        x -> dep = Dep(x -> rs) + 1;
        return x;
    }
    #undef Dep
    
    inline heap* pop() {
        return merge(ls, rs);
    }
} *root;


inline bool check_less(int flag, int x, int y) {
    if (flag == 1) return compare(x, 1, 1, y, 1, 1);
    if (flag == 2) return compare(1, x, 1, 1, y, 1);
    if (flag == 3) return compare(1, 1, x, 1, 1, y);
}

inline void swap(int *a, int x, int y) {
    int t;
    t = a[x];
    a[x] = a[y];
    a[y] = t;
}

void sort(int l, int r, int flag, int *A) {
    if (l >= r) return;
    swap(A[(l + r >> 1)], A[r]);
    int x = A[r], i = l - 1;
    for (int j = l; j <= r; ++j) {
        if (check_less(flag, A[j], x)) {
            i++;
            swap(A, i, j);
        }
    }
    i += 1;
    A[r] = A[i];
    A[i] = x;
    sort(l, i - 1, flag, A);
    sort(i + 1, r, flag, A);
}

void init(int n) {
    for (int i = 1; i <= n; ++i)
        X[i] = Y[i] = Z[i] = i;
    sort(1, n, 1, X);
    sort(1, n, 2, Y);
    sort(1, n, 3, Z);
}

inline void insert(int _X, int _Y, int _Z) {
    root = merge(root, new(_X, _Y, _Z)heap);
}

void get_kth(int n, int k, int *x, int *y, int *z) {
    init(n); //sort for x, y and z
    root = new(1, 1, 1)heap;
    int _X, _Y, _Z;
    while (--k) {
        _X = root -> _X, _Y = root -> _Y, _Z = root -> _Z;
        if (_Z != n) insert(_X, _Y, _Z + 1);
        if (_Z == 1) {
            if (_Y == 1 && _X != n) insert(_X + 1, _Y, _Z);
            if (_Y != n) insert(_X, _Y + 1, _Z);
        }
        root = root -> pop();
    }
    *x = X[root -> _X], *y = Y[root -> _Y], *z = Z[root -> _Z];
}

 

CST2018 3-5 Prefix (20%)

一道简单的KMP，就是考虑每个节点为结尾多出来多少重复的。

比较简单。

#include <cstdio>
#include <cstring>

using namespace std;
typedef long long ll;
const int N = 2e7 + 5;

int f[N];
int cnt[N];
char str[N];
int len;

void KMP(int len) {
    int i = 0, j = -1;
    f[0] = -1;
    while (i < len) {
        if (j == -1 || str[i] == str[j]) {
            i += 1;
            j += 1;
            f[i] = j;
        }
        else j = f[j];
    }
    f[0] = 0;
}

int main() {
    gets(str);
    len = strlen(str);
    KMP(len);
    ll ans = 0;
    memset(cnt, 0, sizeof(cnt));
    for (int i = 1; i <= len; ++i) {
        cnt[i] = cnt[f[i]];
        cnt[i]++;
        ans += cnt[i];
    }
    printf("%lld\n", ans);
    return 0;
}

 

CST2018 3-6 Match (20%)

Treap的应用：

插入：基本操作。

删除：基本操作。

翻转：基本操作。

比较大小：用hash比较。

所以要记录两个值：以某个节点为根的顺序的hash和逆序的hash。

写起来比较麻烦。

#include <cstdio>

using namespace std;
const int N = 4e5 + 5;
const int LEN = 10e5 + 5;
const int P1 = 951413;
const int P2 = 1e9 + 7;

int n, m;

template<class T> inline void swap(T &x, T &y) {
    register T tmp;
    tmp = x, x = y, y = tmp;
}


namespace treap {
    struct node;
    node *root, *null;
    int base[LEN];
    
    inline int cal_hash(int hash1, int sz1, int ch, int hash2, int sz2) {
        int ret = (hash2 + 1ll * ch * base[sz2] % P2) % P2;
        ret = (ret + 1ll * hash1 * base[sz2 + 1] % P2) % P2;
        return ret;
    }
    
    struct node {
        node *ls, *rs;
        int sz, rev, hashl, hashr;
        int ch;
        
        #define Len (1 << 16)
        inline void* operator new(size_t, int _v = 0) {
            static node *mempool, *c;
            if (mempool == c)
                mempool = (c = new node[Len]) + Len;
            c -> ls = c -> rs = null;
            c -> sz = 1;
            c -> rev = 0;
            c -> hashl = c -> hashr = c -> ch = _v;
            return c++;
        }
        #undef Len
        
        inline void reverse() {
            rev ^= 1;
            swap(ls, rs);
            swap(hashl, hashr);
        }
        
        inline node* push() {
            if (rev) {
                ls -> reverse(), rs -> reverse();
                rev = 0;
            }
            return this;
        }
        
        inline node* update() {
            sz = ls -> sz + rs -> sz + 1;
            ls -> push(), rs -> push();
            hashl = cal_hash(ls -> hashl, ls -> sz, ch, rs -> hashl, rs -> sz);
            hashr = cal_hash(rs -> hashr, rs -> sz, ch, ls -> hashr, ls -> sz);
            return this;
        }
    };
        
    inline void init() {
        null = new()node;
        null -> ls = null -> rs = null;
        null -> sz = null -> hashl = null -> hashr = 0;
        
        base[0] = 1;
        for (int i = 1; i < LEN; ++i)
            base[i] = 1ll * base[i - 1] * P1 % P2;
    }
    
    inline unsigned int Rand() {
        static unsigned int res = 2333;
        return res += res << 2 | 1;
    }
    inline int random(int x, int y) {
        return Rand() % (x + y) < x;
    }
    
    void build(node *&p, int l, int r, int *a) {
        if (l > r) {
            p = null;
            return;
        }
        p = new(a[l + r >> 1])node;
        if (l == r) {
            p -> update();
            return;
        }
        build(p -> ls, l, (l + r >> 1) - 1, a);
        build(p -> rs, (l + r >> 1) + 1, r, a);
        p -> update();
    }
    
    void merge(node *&p, node *x, node *y) {
        if (x == null || y == null)
            p = x == null ? y -> push() : x -> push();
        else if (random(x -> sz, y -> sz)) {
            p = x -> push();
            merge(p -> rs, x -> rs, y);
        } else {
            p = y -> push();
            merge(p -> ls, x, y -> ls);
        }
        p -> update();
    }
     
    void split(node *p, node *&x, node *&y, int k) {
        if (!k) {
            x = null, y = p -> push();
            return;
        }
        if (k == p -> sz) {
            x = p -> push(), y = null;
            return;
        }
        if (p -> ls -> sz >= k) {
            y = p -> push();
            split(p -> ls, x, y -> ls, k);
            y -> update();
        } else {
            x = p -> push();
            split(p -> rs, x -> rs, y, k - p -> ls -> sz - 1);
            x -> update();
        }
    }
}
using namespace treap;

int a[N];

int main() {
    char ch;
    int op;
    int pos, tmp;
    int pos1, pos2, len;
    node *x, *y, *z;
    int hash1, hash2, ans = 0;
    scanf("%d %d\n", &n, &m);
    for (int i = 1; i <= n; ++i) {
        ch = getchar();
        while (!('a' <= ch && ch <= 'z')) ch = getchar();
        a[i] = ch - 'a' + 1;
    }
    
    init();
    build(root, 1, n, a);
    while (m--) {
        scanf("%d", &op);
        if (op == 1) {
            scanf("%d", &pos);
            ch = getchar();
            while (!('a' <= ch && ch <= 'z')) ch = getchar();
            tmp = ch - 'a' + 1;
            split(root, x, y, pos);
            z = new(tmp)node;
            merge(root, x, z); merge(root, root, y);
            //root = x + y, new_root = x + z + y
        }
        if (op == 2) {
            scanf("%d", &pos);
            split(root, x, y, pos - 1); split(y, y, z, 1);
            merge(root, x, z);
            //root = x + y + z, new_root = x + z
        }
        if (op == 3) {
            scanf("%d %d", &pos1, &pos2);
            split(root, x, y, pos1 - 1), split(y, y, z, pos2 - pos1 + 1);
            y -> reverse();
            merge(root, x, y -> push()), merge(root, root, z);
            //root = x + y + z, y -> rev
        }
        if (op == 4) {
            scanf("%d %d %d", &pos1, &pos2, &len);
            split(root, x, y, pos1 - 1), split(y, y, z, len);
            hash1 = y -> hashl;
            merge(root, x, y), merge(root, root, z);
            
            split(root, x, y, pos2 - 1), split(y, y, z, len);
            hash2 = y -> hashl;
            merge(root, x, y), merge(root, root, z);
            ans += (hash1 == hash2);
        }
    }
    printf("%d\n", ans);
    return 0;
}

 

CST2018 3-7 History (15%)

强制在线。

简单hash。

 

CST2018 3-8 Shortest (15%)

堆优化Dijkstra。

其实我觉得spfa加SLF还是能过。。。