Tsinghua 2018 DSA PA2简要题解

反正没时间写，先把简要题解（嘴巴A题）都给他写了记录一下。

upd：任务倒是完成了，我也自闭了。

CST2018 2-1 Meteorites：

　　乘法版的石子合并，堆 + 高精度。

　　写起来有点烦貌似。

upd：由于内存问题我高精度是动态开点，同时用的是可并堆（比较简单）。

#include <cstdio>
#include <cmath>
#include <cstring>

using namespace std;
typedef double lf;
typedef long long ll;
const lf pi = acos(-1.0);
const int N = 200005;
const int MaxLen = 2000005;
const int MOD = 10000;

struct BigNumber;
inline int getint();
inline void getInt(BigNumber &res); // get Big number
inline void print(ll *num, int Len);

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

int n;

struct Complex {
    lf x, y;
    
    Complex(lf _x = 0, lf _y = 0) : x(_x), y(_y) {
    }
    ~Complex() {
    }
    
    Complex operator +(const Complex &_c) {
        return Complex(x + _c.x, y + _c.y);
    }
    Complex operator -(const Complex &_c) {
        return Complex(x - _c.x, y - _c.y);
    }
    Complex operator *(const Complex &_c) {
        return Complex(x * _c.x - y * _c.y, x * _c.y + y * _c.x);
    }
    Complex operator *(const lf &_x) {
        return Complex(_x * x, _x * y);
    }
    Complex operator !() {
        return Complex(x, -y);
    }
} w[MaxLen], A[MaxLen], B[MaxLen], C[MaxLen];

struct BigNumber {
    ll *x;
    int len;
    
    BigNumber() {
        x = new ll[1];
        x[0] = 0;
        len = 0;
    }
    
    void destroy() {
        if (x) delete[] x;
    }
    
    ~BigNumber() {
        destroy();
    }
    
    void ChangeSize(int length) {
        if (x) delete[] x;
        x = new ll[length + 1];
        memset(x, 0, (length + 1) * sizeof(x));
        len = 0;
    }
    
    void zero() {
        ChangeSize(0);
        x[0] = 0;
        len = 0;
    }
    void one() {
        ChangeSize(0);
        x[0] = 1;
        len = 0;
    }
    
    void copy(const BigNumber &_num) {
        ChangeSize(_num.len);
        len = _num.len;
        for (int i = len; i >= 0; --i)
            x[i] = _num.x[i];
    }
    
    inline bool operator > (const BigNumber &_num) const {
        if (len > _num.len) return 1;
        if (len < _num.len) return 0;
        for (int i = len; i >= 0; --i) {
            if (x[i] > _num.x[i]) return 1;
            if (x[i] < _num.x[i]) return 0;
        }
        return 1;
    }
    
    void print() {
        for (int i = len; i >= 0; --i) 
            printf(i == len ? "%lld" : "%04lld", x[i]);
        puts("");
    }
};

struct heap {
    heap *ls, *rs;
    BigNumber num;
    int dep;
    
    void *operator new(size_t) {
        static heap mempool[N << 2], *c = mempool;
        c -> ls = c -> rs = NULL;
        c -> dep = 1;
        c -> num.zero();
        return c++;
    }
    
    inline void get_value(const BigNumber &_num) {
        num.copy(_num);
    }
    
    #define Dep(p) (p ? p -> dep : 0)
    inline void update() {
        dep = Dep(rs) + 1;
    }
    
    friend heap* merge(heap *x, heap *y) {
        if (!x) return y;
        if (!y) return x;
        if (x -> num > y -> num) swap(x, y);
        x -> rs = merge(x -> rs, y);
        if (Dep(x -> rs) > Dep(x -> ls))
            swap(x -> ls, x -> rs);
        x -> update();
        return x;
    }
    #undef Dep
    
    inline heap* pop() {
        this -> num.ChangeSize(0);
        return merge(ls, rs);
    }
} *Root;


void work(const BigNumber &a, const BigNumber &b, BigNumber &c) {
    int n = a.len, m = b.len, l = a.len + b.len + 4;
    c.ChangeSize(l);
    
    for (int k = 0; k <= l; ++k) c.x[k] = 0;
    
    for (int i = 0; i <= n; ++i)
        for (int j = 0; j <= m; ++j)
            c.x[i + j] += a.x[i] * b.x[j];            
    for (int k = 0; k < l; ++k) {
        c.x[k + 1] += c.x[k] / MOD;
        c.x[k] %= MOD;
    }
    
    while (c.x[l] == 0) --l;
    c.len = l;
}

int main() {
    BigNumber ans, tmp, a, b, c;
    heap *tmp_node;
    
    n = getint();
    tmp.one();
        
    Root = new()heap;
    Root -> get_value(tmp);    
    
    for (int i = 1; i <= n; ++i) {
        getInt(tmp);
        tmp_node = new()heap;
        tmp_node -> get_value(tmp);
        
        Root = merge(Root, tmp_node);
    }
    
    
    ans.one();
    for (int i = 1; i <= n; ++i) {
        a.copy(Root -> num);
        Root = Root -> pop();
        b.copy(Root -> num);
        Root = Root -> pop();
        /*
        puts("a and b:");
        a.print();
        b.print();
        puts("---------");
        */
        work(a, b, c);
        /*
        puts("c:");
        c.print();
        */
        tmp.copy(ans);
        if (i != 1) {
            /*
            puts("----");
            tmp.print();
            c.print();
            */
            work(tmp, c, ans);
        }
        /*
        puts("ans:");
        ans.print();
        */
        tmp_node = new()heap;
        tmp_node -> get_value(c);
        
        Root = merge(Root, tmp_node);
    }
    ans.print();
    
    return 0;
}

const int BUF_SIZE = 30;
char buf[BUF_SIZE], *buf_s = buf, *buf_t = buf + 1;
#define isdigit(x) ('0' <= x && x <= '9')
#define PTR_NEXT() { 
    if (++buf_s == buf_t) 
        buf_s = buf, buf_t = buf + fread(buf, 1, BUF_SIZE, stdin); 
}

int getint() {
    register int x = 0;
    while (!isdigit(*buf_s)) PTR_NEXT();
    while (isdigit(*buf_s)) {
        x = x * 10 + *buf_s - '0';
        PTR_NEXT();
    }
    return x;
}

void getInt(BigNumber &res) {
    static ll num[50];
    static int len, Len, cnt, base;
    memset(num, 0, sizeof(num)), len = 0;
    for (int i = 0; i < 50; ++i) num[i] = 0;

    while (!isdigit(*buf_s)) PTR_NEXT();
    while (isdigit(*buf_s) && buf_s != buf_t) {
        num[len++] = *buf_s - '0';
        PTR_NEXT();
    }
    len -= 1;
    
    res.ChangeSize((len + 4) / 4 - 1);
    Len = -1, cnt = 0;
    for (int i = len; i >= 0; --i) {
        cnt++;
        if (cnt % 4 == 1) Len += 1, base = 1;
        res.x[Len] += base * num[i];
        base *= 10;
    }
    res.len = Len;
    
    /*
    for (int i = 0; i <= len; ++i)
        printf("%lld ", num[i]);
    puts("");    
    
    res.print();
    */
}

CST2018 2-2 Circuit

　　首先是一个二进制trie + 贪心，但是由于有间隔限制，所以这个trie要支持插入和删除标记操作。

　　写起来并不麻烦。

upd：哪个xx卡内存。。。要把指针改成数组下标，同时把叶子和非叶子分开。

#include <cstdio>
#include <cstring>
    
using namespace std;
typedef unsigned long long ull;
const int N = 5e5 + 5;
const int SIZE = 18e6 + 5;
int n, k;
int a[100];
ull f[N];

struct trie_node {
    int son[2];
    int cnt;
} trie[SIZE];
int Root;
int cnt = 0;

struct leaf_node {
    int cnt;
    int next;
} leaf[N];
int cnt_leaf = 0;


int get_new() {
    ++cnt;
    trie[cnt].son[0] = trie[cnt].son[1] = -1;
    trie[cnt].cnt = 0;
    return cnt;
}

int get_new_leaf() {
    ++cnt_leaf;
    leaf[cnt_leaf].cnt = 0;
    leaf[cnt_leaf].next = -1;
    return cnt_leaf;
}

struct Queue {
    int next, value;
} q[N];
int size;

void init() {
    Root = get_new();
}

void trie_add(int *a, int id) {
    int tmp = Root;
    for (int i = 1; i <= 64; ++i) {
        trie[tmp].cnt += 1;
        if (trie[tmp].son[a[i]] == -1) {
            if (i != 64) trie[tmp].son[a[i]] = get_new();
            else trie[tmp].son[a[i]] = get_new_leaf();
        }
        tmp = trie[tmp].son[a[i]];
    }
    
    //leaf
    leaf[tmp].cnt += 1;
    int t = leaf[tmp].next;
    if (t == -1) {
        size += 1;
        leaf[tmp].next = size;
        q[size].next = -1;
        q[size].value = id;
    } else {
        while (q[t].next != -1) t = q[t].next;
        size += 1;
        q[t].next = size;
        q[size].next = -1;
        q[size].value = id;
    }    
}

void trie_delete(int *a) {
    int tmp = Root;
    for (int i = 1; i <= 64; ++i) {
        trie[tmp].cnt -= 1;
        tmp = trie[tmp].son[a[i]];
    }
    
    //leaf
    leaf[tmp].cnt -= 1;
    leaf[tmp].next = q[leaf[tmp].next].next;
}

int trie_find(int *a, int id) {
    int tmp = Root;
    int t;
    for (int i = 1; i <= 64; ++i) {
        if (i != 64) {
            t = trie[tmp].son[!a[i]];
            if (t != -1 && trie[t].cnt != 0)
                tmp = trie[tmp].son[!a[i]];
            else
                tmp = trie[tmp].son[a[i]];
        } else {
            t = trie[tmp].son[!a[i]];
            if (t != -1 && leaf[t].cnt != 0)
                tmp = trie[tmp].son[!a[i]];
            else
                tmp = trie[tmp].son[a[i]];
        }
    }
    int x = leaf[tmp].next;
    while (q[x].value == id) {
        x = q[x].next;
    }
    return q[x].value;
}

//--------------------------------------------------------------------
//--------------------------------------------------------------------

void split(ull x) {
    memset(a, 0, sizeof(a));
    for (int i = 64; x; x >>= 1, --i) {
        a[i] = x % 2;
    }
    /*
    for (int i = 1; i <= 64; ++i)
        printf("%d", a[i]);
    puts("");
    */
}

void add_in_trie(int i) {
    if (i < 0 || i > n) return;
    //printf("Add    : %d %llu
", i, f[i]);
    split(f[i]);
    trie_add(a, i);
}

void delete_in_trie(int i) {
    if (i < 0 || i > n) return;
    //printf("Delete : %d %llu
", i, f[i]);
    split(f[i]);
    trie_delete(a);
}

int get_ans(int i) {
    //printf("Find   : %d %llu
", i, f[i]);
    split(f[i]);
    return trie_find(a, i);
}


int main() {
    ull x;
    scanf("%d%d", &n, &k);
    /*
    for (int i = 1; i <= n; ++i) {
        scanf("%llu", &x);
        printf("%llu
", x);
        f[i] = x;
        split(x);        
    }
    */
    
    int L, R, nowL, nowR;
    nowL = 1, nowR = 0;
    L = 1 - k - 1;
    R = 1 + k + 1;
    init();
    for (int i = 1; i <= n; ++i) {
        //add in trie
        while (nowR < R) {
            nowR += 1;
            scanf("%llu", &f[nowR]);
            split(f[nowR]);
            add_in_trie(nowR);
        }
        //delete in trie
        while (nowL < L) {
            delete_in_trie(nowL);
            nowL += 1;
        }
        
        //printf("%d %d %d
", i, nowL, nowR);
        printf("%d
", get_ans(i) - 1);
        
        //change the segment
        L += 1;
        R += 1;
        if (L > n) L = n;
        if (R > n) R = n;
    }
    
    return 0;
}

 CST2018 2-3-1 Mooney(basic)

　　求一个有向图的强连通分量个数，直接tarjan就好了。

　　写起来 = 抄板子。

upd：没写。

CST2018 2-3-2 Mooney

　　两个小问题：

　　　　第一个就是求最短路，Dijkstra。

　　　　第二个先按照前一道题tarjan求强连通分量，然后对DAG树形DP。

　　写起来有点麻烦。

upd：第一问我写了SLF优化的spfa，应该不卡，第二问要注意有的连通分量走不到T要删掉。

#include <cstdio>

using namespace std;
const int N = 5e5 + 5;
const int M = 12e5 + 5;
const int inf = 1e9;


int n, m;
int f[N];
int tot, first[N];
int TOT, FIRST[N];

struct edge {
    int next, to;
    edge() {}
    edge(int _n, int _t) : next(_n), to(_t) {}
} e[M], E[M];

inline void add_edge(int x, int y) {
    e[++tot] = edge(first[x], y), first[x] = tot;
}

int q[N], v[N], dis[N];
void spfa(int S) {
    int p, x, y, l, r;
    
    for (x = 1; x <= n; ++x)
        dis[x] = inf;
    
    q[0] = S, dis[S] = (f[S] == 0), v[S] = 1;
    for (l = r = 0; l != (r + 1) % N; ) {
        p = q[l], ++l %= N;
        for (x = first[p]; x; x = e[x].next) {
            y = e[x].to;
            if (dis[p] + (f[y] == 0) < dis[y]) {
                dis[y] = dis[p] + (f[y] == 0);
                if (!v[y]) {
                    v[y] = 1;
                    if (dis[y] < dis[q[l]]) q[(l += N - 1) %= N] = y;
                    else q[++r %= N] = y;
                }
            }
        }
        v[p] = 0;
    }
}

int __main1__() {
    spfa(1);
    printf("%d
", dis[n]);
}


int low[N], dfn[N], vis[N], inq[N], s[N], w[N];
int Cnt[N], num;
int VIS[N], ans[N];
int cnt, top;
int S, T;

inline int min(int x, int y) {
    return x < y ? x : y;
}

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


void dfs(int p){
    low[p] = dfn[p] = ++cnt;
    vis[p] = inq[p] = 1;
    s[++top] = p;
    int x, y;
    for (x = first[p]; x; x = e[x].next)
        if (!vis[(y = e[x].to)]){
            dfs(y);
            low[p] = min(low[p], low[y]);
        }else
        if (inq[y]) low[p] = min(low[p], dfn[y]);
    if (low[p] == dfn[p]){
        ++num, y = 0;
        while (y != p){
            inq[(y = s[top--])] = 0;
            w[y] = num;
            if (f[y] == 1) 
                ++Cnt[num];
        }
    }
}

inline void ADD_EDGE(int x, int y) {
    E[++TOT] = edge(FIRST[x], y), FIRST[x] = TOT;
}

void rebuild_graph() {
    int x, y;
    for (int i = 1; i <= n; ++i)
        for (x = first[i]; x; x = e[x].next)
            if (w[i] != w[(y = e[x].to)])
                ADD_EDGE(w[i], w[y]);
}

int tag[N];

void work(int p) {
    int x, y;
    ans[p] = 0;
    if (p == T) {
        tag[p] = 1;
        ans[p] = Cnt[T];
        return;
    }
    for (x = FIRST[p]; x; x = E[x].next) {
        if (!VIS[y = E[x].to]) {
            VIS[y] = 1;
            work(y);
        }
        if (tag[y]) tag[p] = 1;
        ans[p] = max(ans[p], ans[y]);
    }
    if (tag[p] == 1)
        ans[p] += Cnt[p];
}

int __main2__() {
    for (int i = 1; i <= n; ++i)
        if (!vis[i])
            dfs(i);
    rebuild_graph();
    
    S = w[1];
    T = w[n];
    work(S);
    
    printf("%d
", ans[S]);
}

int main() {
    int x, y;
    char ch;
    
    scanf("%d%d
", &n, &m);
    for (int i = 1; i <= n; ++i) {
        ch = getchar();
        while (ch != 'm' && ch != 'M')
            ch = getchar();
        if (ch == 'M') f[i] = 0;
        if (ch == 'm') f[i] = 1;
    }
    
    for (int i = 1; i <= m; ++i) {
        scanf("%d %d", &x, &y);
        add_edge(x + 1, y + 1);
    }
    
    __main1__();
    __main2__();    
        
    return 0;
}

CST2018 2-4 Sort

　　我记得好像是原题，忘了咋做了。

　　大概想法是归并排序的时候分析归并子序列1的前两个数和子序列2的前一个数的大小，不能证明其上界。。。

　　写起来不麻烦。。就是不知道对不对。

upd：自闭了，四路归并写不来。

CST2018 2-5 ChromPoly

　　也没有什么想法，直接dfs好像就可以了。

　　问题是怎么判断两张图是同构的，这样子可以大幅度剪枝，甚至在小情况的时候进行打表预处理。

　　然后这是个NP问题，我xxxx。

　　我还是决定用hash来做。。但是还是没想好怎么hash

　　写起来不麻烦，如果hash搞定了的话。

upd：并不是hash，有别人的代码，戳这里。写到一半自闭了，不想写了。

CST2018 2-6 Temperature

　　二维数组，单点修改，矩阵求和，在线算法。

　　好像可以写二维的树状数组，子矩阵可以通过左上角二维前缀和解决。

　　写起来比较简单。

upd：好像没什么好讲的，要是每道题都这么简单就好了。

#include <cstdlib>
#include "temperature.h"

using namespace std;
const int N = 1205;
const int M = 1205;

int sum[N][M];
int _t[N][M];

void change(int, int, int);

void init(int n, int m, int **temp) {
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j) {
            change(i, j, temp[i][j]);
            _t[i][j] = temp[i][j];
        }
}

inline int Q(int x, int y) {
    int res = 0;
    for (int i = x; i; i -= i&(-i))
        for (int j = y; j; j -= j&(-j))
            res += sum[i][j];
    return res;
}

int query(int x1, int y1, int x2, int y2) {
    return (Q(x2, y2) - Q(x2, y1 - 1) - Q(x1 - 1, y2) + Q(x1 - 1, y1 - 1)) / ((x2 - x1 + 1) * (y2 - y1 + 1));
}

void change(int x, int y, int temp) {
    int del = temp - _t[x][y];
    _t[x][y] = temp;
    for (int i = x; i < N; i += i&(-i))
        for (int j = y; j < M; j += j&(-j))
            sum[i][j] += del;
}

CST2018 2-7 Virus

　　就是求所有离0最远的1，直接bfs就好了。

　　写起来非常简单。

upd： 好像也没什么好讲的，但是少了5分。。。有毒。

#include <cstdio>

using namespace std;
const int N = 1005;
const int M = 1005;
const int CNT = N * M;

const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};

int ans;
int n, m;
int w[N][M];
int x[CNT], y[CNT];
int time[CNT], vis[CNT];
int q[CNT], l, r;
int cnt, cnt_virus;


inline void _max(int &x, int y) {
    if (x < y) x = y;
}

inline void push_q(int x, int y, int t) {
    r++;
    q[r] = w[x][y];
    vis[w[x][y]] = 1;
    time[w[x][y]] = t;
    ans += t;
    ++cnt_virus;
}

inline bool IN(int x, int y) {
    return 0 < x && x <= n && 0 < y && y <= m;
}

int main() {
    char ch;
    int C;
    int _x, _y, __x, __y;
    scanf("%d%d", &n, &m);
    cnt = 0;
    l = 1, r = 0;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j) {
            w[i][j] = ++cnt;
            x[cnt] = i, y[cnt] = j;
            
            ch = getchar();
            while (ch != '0' && ch != '1') ch = getchar();
            if (ch == '0') push_q(i, j, 0);
        }
    while (l <= r) {
        C = q[l];
        _x = x[C], _y = y[C];
        for (int i = 0; i < 4; ++i) {
            __x = _x + dx[i], __y = _y + dy[i];
            if (IN(__x, __y) && !vis[w[__x][__y]])
                push_q(__x, __y, time[w[_x][_y]] + 1);
        }
        ++l;
    }
    printf("%d
", ans);
    return 0;
}

CST2018 2-8 MST

　　求最小生成树。

　　ctrl c + ctrl v = AC。

20分题：1，2，3-2，4， 5， 6。

15分题：3-1， 7， 8。

吐槽：15分题和20分题真的是一个难度的吗？助教nb。