BUPT2017 wintertraining(16) #9

龟速补题。目前基本弃坑。已暂时放弃 D、I 两题。

下面不再写题意了直接说解法注意事项之类，直接放contest链接。

https://vjudge.net/contest/151537

 

A.The Perfect Stall

很明显的二分图匹配，可以跑最大流

我是直接写的匈牙利算法，hungary，不是hungry

(虽然读音差不多???

事实证明浪了一个寒假我连hungary算法都不会写了

#include <cstdio>
#include <vector>
#include <cstring>

using namespace std;

vector <int> e[210];
int n, m, tim, ans, pre[410], vis[410];

int hungary(int u) {
    vis[u] = tim;
    for(int v, i = 0;i < e[u].size();i ++) {
        v = e[u][i];
        if(vis[v] != tim) {
            vis[v] = tim;
            if(!pre[v] || hungary(pre[v])) 
                return pre[v] = u, 1;
        } 
    }
    return 0;
}

int main() {
    while(~scanf("%d %d", &n, &m)) {
        ans = 0;
        memset(e, 0, sizeof e);
        memset(pre, 0, sizeof pre);
        memset(vis, 0, sizeof vis);
        for(int u, v, i = 1;i <= n;i ++) {
            scanf("%d", &u);
            for(int j = 1;j <= u;j ++) {
                scanf("%d", &v);
                e[i].push_back(v + n);
            }
        }
        for(tim = 1;tim <= n;tim ++)
            ans += hungary(tim);
        printf("%d\n", ans);
    } 
    return 0;
}

 

B.Nim

Nim问题的拓展:

给定一种局面，询问当前局面下

你有多少种不同的保证必胜的操作方法

(又举例把自己难住所以去复习了一下)

显然只要使操作后石子堆异或和为0即可

 

题外话，之前没怎么注意过运算优先级

然而昨天才认识到AND优先级比OR高

还有位运算清楚不清楚优先级最好加括号

因为今天才知道XOR优先级比 <= 低

#include <cstdio>

int n, k[1010]; 

int main() {
    while(scanf("%d", &n), n != 0) {
        int ans = 0, num = 0;
        for(int i = 1;i <= n;i ++) 
            scanf("%d", &k[i]), num ^= k[i];
        for(int i = 1;i <= n;i ++)
            ans += ((num ^ k[i]) < k[i]);
        printf("%d\n", ans);
    }
    return 0;
}

 

C.sightseeing

一个最短路和次短路计数问题

// unidirectional单向！不要看见un就以为是什么否定前缀

// 就以为是无向边了好吗！naive，多学点英语不好吗

计数比较简单啦，开数组num[2][maxn]

dis[i]表示起点到 i 的最短距离

num[0][i]到 i 的距离为dis[i]的路径数

num[1][i]到 i 的距离为dis[i] + 1的路径数

初始化num[0][s] = 1 结果就是num[0][t] + num[1][t]

由于同时记录最短路和次短路所以如果用spfa会增加很多入队次数可能TLE?

不是很清楚但是我是用的spfa过的，别人题解几乎清一色的dijkstra?

 

在dr帮助下终于解决了自己的一个困惑

在计数用的spfa中需要同时记录节点和距离

距离数组ddis因为是会被更新的所以入队时需要记录下来距离！

 

当然我的写法偏非主流，参考价值有限

#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>

using namespace std;

struct node{int x, y, z;};

const int maxn = 1010, inf = 111111111;

int Case, n, m;

int dis[maxn], ddis[maxn], flag[maxn], vis[3][maxn], num[2][maxn];

vector <pair<int, int> > e[maxn];

queue <int> q;

queue <node> qq;

int main() {
    scanf("%d", &Case);
    while(Case -- ) {
        memset(e, 0, sizeof e);
        int u, v, w, s, t, p, dd, dp;
        scanf("%d %d", &n ,&m);
        for(int i = 1;i <= m;i ++) {
            scanf("%d %d %d", &u, &v, &w);
            e[u].push_back(make_pair(v, w));
        }
        scanf("%d %d", &s, &t);
        for(int i = 1;i <= n;i ++)
            dis[i] = ddis[i]= inf;      
        dis[s] = ddis[s] = 0, q.push(s);
        while(!q.empty()) {
            u = q.front(), flag[u] = 0, q.pop();
            for(int i = 0;i < e[u].size();i ++) {
                v = e[u][i].first, w = e[u][i].second;
                if(dis[u] + w < dis[v]) {
                    dis[v] = dis[u] + w;
                    if(v != t && !flag[v]) q.push(v), flag[v] = 1;
                }
            }
        }
        num[0][s] = 1;
        qq.push((node) {s, 0, 0});
        while(!qq.empty()) {
            u = qq.front().x, p = qq.front().y, dp = qq.front().z, vis[p][u] = 0, qq.pop();
            for(int i = 0;i < e[u].size();i ++) {
                v = e[u][i].first, w = e[u][i].second;
                if(dp + w <= ddis[v]) {
                    ddis[v] = dp + w;
                    if(ddis[v] == dis[v]) {
                        num[0][v] += num[p][u];
                        if(v != t && !vis[0][v]) vis[0][v] = 1, qq.push((node) {v, 0, ddis[v]});
                    }
                    else if(ddis[v] == dis[v] + 1) {
                        num[1][v] += num[p][u];
                        if(v != t && !vis[1][v]) vis[1][v] = 1, qq.push((node) {v, 1, ddis[v]});
                    }
                    else if(v != t && !vis[2][v]) vis[2][v] = 1, qq.push((node) {v, 2, ddis[v]});
                }
                else if(dp + w == dis[v] + 1) {
                    num[1][v] += num[p][u];
                    if(v != t && !vis[1][v]) vis[1][v] = 1, qq.push((node) {v, 1, dp + w});
                }
            }
            if(p < 2) num[p][u] = 0;
        }
        printf("%d\n", num[0][t] + num[1][t]);
        num[0][t] = num[1][t] = 0;
    }  
    return 0;
} 

 

D.Let it bead

这个题完全是抄别人的代码啊

polya原理是什么啊，好吃吗

等我会了再把坑填上

#include <cstdio>

long long f[50];

int gcd(int x, int y) {
    return y ? gcd(y, x % y) : x;
}

int main() {
    int c, s;
    while(scanf("%d %d", &c, &s), c != 0) {
        f[0] = 1;
        for(int i = 1;i <= s;i ++)
            f[i] = f[i - 1] * c;
        int sum = 0, cnt = 0;
        for(int i = 1;i <= s;i ++)
            sum += f[gcd(s, i)];
        if(s & 1) cnt = s * f[(s + 1) >> 1];
        else cnt = (s >> 1) * (f[(s >> 1) + 1] + f[s >> 1]);
        printf("%d\n", ((sum + cnt) >> 1) / s); 
    }
    return 0;
}

 

E.going home

一个比较明显的最小费用最大流

s到H连边，流量1，费用0

m到t连边，流量1，费用0

h到m连边，流量1，费用为距离

直接抄的板子

#include <deque>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn = 1010, maxm = 30010, inf = 0x3f3f3f3f;

int dis(int x, int y) {
    if(x < y) return y - x;
    return x - y;
}

struct point {
    int x, y;
    int operator - (const point & a) const {
        return dis(x, a.x) + dis(y, a.y);
    }
}a[maxn], b[maxn];

char mmp[maxn];
int n, m, s, t, c1, c2, d[maxn], v[maxn], pre[maxn], incf[maxn];
int len, ans, head[maxn], to[maxm], cap[maxm], cost[maxm], next[maxm], path[maxn];

void add(int x, int y, int v, int w) {
    to[++ len] = y, cap[len] = v, next[len] = head[x], head[x] = len, cost[len] = w;
    to[++ len] = x, cap[len] = 0, next[len] = head[y], head[y] = len, cost[len] = -w;
}

bool spfa() {
    deque <int> q;
    q.push_back(s), incf[s] = inf;
    memset(d, 0x3f, sizeof d), d[s] = 0;
    while(!q.empty()) {
        int x = q.front();
        q.pop_front(), v[x] = 0;
        for(int i = head[x];i;i = next[i]) {
            if(cap[i] && d[to[i]] > d[x] + cost[i]) {
                d[to[i]] = d[x] + cost[i];
                pre[to[i]] = x, path[to[i]] = i;
                incf[to[i]] = min(incf[x], cap[i]);
                if(!v[to[i]]) {
                    v[to[i]] = 1;
                    if(q.empty() || d[to[i]] < d[q.front()]) q.push_front(to[i]);
                    else q.push_back(to[i]);
                }
            }
        }
    }
    if(d[t] == inf) return 0;
    for(int i = t;i != s;i = pre[i]) {
        cap[path[i]] -= incf[t];
        cap[path[i] ^ 1] += incf[t];
    }
    return ans += incf[t] * d[t], 1;
}

int main() {
    s = 0, t = 201;
    while(scanf("%d %d", &n, &m), n != 0) {
        len = 1, c1 = c2 = ans = 0;
        memset(head, 0, sizeof head);
        for(int i = 1;i <= n;i ++) {
            scanf("%s", mmp + 1);    
            for(int j = 1;j <= m;j ++)
                if(mmp[j] == 'H') {
                    a[++ c1] = (point){i, j};
                    add(s, c1, 1, 0);
                }
                else if(mmp[j] == 'm') {
                    b[++ c2] = (point){i, j};
                    add(100 + c2, t, 1, 0);
                }
        }    
        for(int i = 1;i <= c1;i ++)
            for(int j = 1;j <= c2;j ++)
                add(i, j + 100, 1, a[i] - b[j]);
        while(spfa());
        printf("%d\n", ans);
    }
    return 0;
}

 

F.Road to Cinema

之前做过的codeforces原题

简单地二分出能到达终点的最小容量

然后在所有容量满足条件的车里找最便宜的即可

#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 200010;

int n, k, s, t;

int a[maxn], b[maxn], c[maxn];

bool judge(int x) {
    long long sum = 0;
    for(int i = 0;i < k;i ++) {
        if(c[i] > x) return 0;
        if(c[i] * 2 <= x) sum += c[i];
        else sum += c[i] * 3 -x;
    }
    return sum <= t;
}

int main() {
    int l = 1000000000, r = 0, mid, ans = -1;
    scanf("%d %d %d %d", &n, &k, &s, &t);
    for(int i = 1;i <= n;i ++)
        scanf("%d %d", &a[i], &b[i]), l = min(l, b[i]), r = max(r, b[i]);
    for(int i = 1;i <= k;i ++)
        scanf("%d", &c[i]);
    sort(c + 1, c + k + 1);
    k ++, c[k] = s;
    for(int i = 0;i < k;i ++)
        c[i] = c[i + 1] - c[i];
    while(l <= r){
        mid = (l + r) >> 1;
        if(judge(mid)) r = mid - 1, ans = mid;
        else l = mid + 1;
    }
    if(ans == -1) printf("-1");
    else {
        mid = 1000000000;
        for(int i = 1;i <= n;i ++)
            if(b[i] >= ans)
                mid = min(mid, a[i]);
        printf("%d", mid);
    }
    return 0;
}

 

G.play with chain

标题应该翻译成捆绑play?

一道很明显的splay

我能不抄板子打出来?不存在的!

我用指针写的双旋的

 

FLIP操作就像文艺平衡树一样

把操作区间左边相邻的点转到root

右边相邻的点转到root的右儿子

因为splay保持了原来的顺序

所以要操作的区间就是root的右儿子的左儿子那棵子树

打个翻转标记就完事了

 

CUT操作其实差不多，只是稍麻烦些

把操作区间左边相邻的点转到root

右边相邻的点转到root的右儿子

然后把要操作的区间拿下来

把剩下的树maintain完成后

把拿下来的区间再放到对应位置即可

#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 300010;

struct node {
    bool rev;
    int v, siz;
    node *c[2];
    void pushdown();
    node *init(int x);
    
    void update() {
        siz = c[0]->siz + c[1]->siz + 1;
    }
    
    int cmp(int k) {
        if(k <= c[0]->siz) return 0;
        if(k == c[0]->siz + 1) return -1;
        return 1;
    }
}Null, spt[maxn];

int n, m, tot, cnt, out[maxn];

node *node::init(int x) {
    v = x, rev = 0, siz = 1;
    c[0] = c[1] = &Null;
    return this;
}

void node::pushdown() {
    if(!rev) return;
    if(c[0] != &Null) c[0]->rev ^= 1;
    if(c[1] != &Null) c[1]->rev ^= 1;
    swap(c[0], c[1]), rev = 0;
}

node *build(int l, int r) {
    if(l == r) return spt[++tot].init(r);
    int mid = (l + r) >> 1;
    node *tmp = spt[++tot].init(mid);
    if(l < mid) tmp->c[0] = build(l, mid - 1);
    if(r > mid) tmp->c[1] = build(mid + 1,r);
    tmp->update();
    return tmp;
}

void print(node *&o) {
    o->pushdown();
    if(o->c[0] != &Null) print(o->c[0]);
    out[cnt ++] = o->v;
    if(o->c[1] != &Null) print(o->c[1]); 
}

void rot(node *&o, int k) {
    o->pushdown();
    node *tmp = o->c[k];
    tmp->pushdown();
    o->c[k] = tmp->c[!k];
    tmp->c[!k]->pushdown();
    tmp->c[!k] = o, o->update();
    tmp->update(), o = tmp;
}

void splay(node *&o, int k) {
    o->pushdown();
    int k1 = o->cmp(k);
    if(k1 == -1) return;
    o->c[k1]->pushdown();
    if(k1) k -= o->c[0]->siz + 1;
    int k2 = o->c[k1]->cmp(k);
    if(~k2) {
        if(k2) k -= o->c[k1]->c[0]->siz + 1;
        splay(o->c[k1]->c[k2], k);
        if(k2 == k1) rot(o, k1);
        else rot(o->c[k1], k2);
    }
    rot(o, k1);
}

int main() {
    int a, b, c, len;
    char str[10];
    while(scanf("%d %d", &n, &m), n != -1) {
        tot = 0, cnt = 0;
        node *root = build(0, n + 1), *tmp;
        while(m --) {
            scanf("%s %d %d", str, &a, &b);
            a ++, b ++, len = b - a + 1;
            if(str[0] == 'C') {
                scanf("%d", &c);
                splay(root, a - 1);
                splay(root->c[1], len + 1);
                tmp = root->c[1]->c[0];
                root->c[1]->c[0] = &Null;
                root->c[1]->update();
                root->update();
                splay(root, c + 1);
                splay(root->c[1], 1);
                root->c[1]->c[0] = tmp;
                root->c[1]->update();
                root->update();
            }
            else {
                splay(root, a - 1);
                splay(root->c[1], len + 1);
                root->c[1]->c[0]->rev ^= 1;
            }
        }
        print(root);
        for(int i = 1;i < n;i ++)
            printf("%d ", out[i]);
        printf("%d\n", out[n]);
    }
    return 0;
}

 

H.animals and puzzle

一看是cf的d题就来做了，结果是div1...

好的这个题我当然是看别人题解做的

首先我们很容易求dp[i][j]表示以(i,j)为右下角的最大正方形边长

然后就用到一个神奇的二分，二分里再套一个RMQ就解决了

这个二分是这样的

对于一个单独的查询，我们二分这个查询的答案为mid

然后再在以(x1 + mid - 1, y1 + mid - 1)为左上角

以(x2, y2)为右下角的正方形区域内求dp数组最大值k

如果k >= mid ，那么显然ans >= mid，即mid合法，l = mid +１

否则显然ans ＜ mid，即mid不合法，r = mid -１

更正！效率为O((n^2+q)logn^2) 

这里的RMQ为方便起见显然推荐倍增

(我一个一维RMQ宁愿线段树，LCA宁愿树剖的人都含泪推荐倍增了

#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 1010;

int n, m, t, x1, y1, x2, y2;

int a[maxn][maxn], f[maxn][maxn][11][11];

int getmax() {
    int p = 0, q = 0, l1 = 1, l2 = 1, tmp1, tmp2;
    while(l1 <= x2 - x1 + 1) l1 <<= 1, p ++;
    p --, l1 >>= 1;
    while(l2 <= y2 - y1 + 1) l2 <<= 1, q ++;
    q -- ,l2 >>= 1;
    tmp1 = max(f[x1 + l1 - 1][y1 + l2 - 1][p][q], f[x2][y1 + l2 - 1][p][q]);
    tmp2 = max(f[x1 + l1 - 1][y2][p][q], f[x2][y2][p][q]);
    return max(tmp1, tmp2);
}

bool judge(int r) {
    x1 += r - 1, y1 += r - 1;
    bool ret = getmax() >= r;
    x1 -= r - 1, y1 -= r - 1;
    return ret;
}

int main() {
    scanf("%d %d", &n, &m);
    for(int i = 1;i <= n;i ++) {
        for(int j = 1;j <= m;j ++) {
            scanf("%d", &a[i][j]);
            if(a[i][j]) f[i][j][0][0] = min(f[i - 1][j - 1][0][0], min(f[i - 1][j][0][0], f[i][j - 1][0][0])) + 1;
            else f[i][j][0][0] = 0;
        }
    }
    
    for(int p = 0, l1 = 1;l1 <= n;l1 <<= 1, p ++)
        for(int q = 0, l2 = 1;l2 <= m;l2 <<= 1, q ++) {
            if(p + q == 0) continue;
            for(int i = l1;i <= n;i ++) {
                for(int j = l2;j <= m;j ++) {
                    if(p != 0) f[i][j][p][q] = max(f[i][j][p - 1][q], f[i - (l1 >> 1)][j][p - 1][q]); 
                    else f[i][j][p][q] = max(f[i][j][p][q - 1], f[i][j - (l2 >> 1)][p][q - 1]);
                }
            }
        }
    
    scanf("%d", &t);
    for(int l, r, mid;t --;) {
        scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
        l = 0, r = min(x2 - x1 + 1, y2 - y1 + 1);
        while(l <= r) {
            mid = (l + r) >> 1;
            if(judge(mid)) l = mid + 1;
            else r = mid - 1;
        }
        printf("%d\n", r);
    }
    return 0;
}

 

I.bear and bowling 4

f[i]代表以 i 为结尾的最大收益

有点奇妙的斜率DP

暂时放弃

 

J.runaway to a shadow

题意清晰，思路简单。

友情提示:这题不卡精度，只要你开的double不是float

不需要什么各种计算几何算法

只需要高中数学知识和cmath函数的计算几何模拟题

因为自己脑残所以写狗了3次

x，y写错。自己分类讨论好的情况忘写一种。pi 初始成3.141415926535。

#include <cmath>
#include <cstdio>
#include <algorithm>

using namespace std;

const int maxn = 200010;

typedef long long ll;

int n, m;

double x0, Y0, v, t, R;

double x[maxn], y[maxn], r[maxn];

double sqr(double x) {
    return x * x;
}

struct line {
    double x, y;
    bool operator < (const line &a) const {
        if(x != a.x) return x < a.x;
        return y < a.y;
    }
}a[maxn];

int main() {
    double pos, tmp, L, RR = 1.0, pi = 3.14159265358, ans = 0.0;
    scanf("%lf %lf %lf %lf %d", &x0, &Y0, &v, &t, &n), R = v * t;
    for(int i = 1;i <= n;i ++) {
        scanf("%lf %lf %lf", &x[i], &y[i], &r[i]);
        if(sqr(x[i] - x0) + sqr(y[i] - Y0) <= sqr(r[i])) {
            puts("1.00000000000");
            return 0;
        }
        if(sqrt(sqr(x[i] - x0) + sqr(y[i] - Y0)) >= R + r[i]) continue;
        pos = atan2((y[i] - Y0), (x[i] - x0)) + pi;
        if(sqr(R) + sqr(r[i]) >= sqr(x[i] - x0) + sqr(y[i] - Y0)) tmp = asin(r[i] / sqrt(sqr(x[i] - x0) + sqr(y[i] - Y0)));
        else tmp = acos((sqr(R) - sqr(r[i]) + sqr(x[i] - x0) + sqr(y[i] - Y0)) / (sqrt(sqr(x[i] - x0) + sqr(y[i] - Y0)) * 2.0 * R));
        m ++, a[m].y = pos + tmp ,a[m].x = pos - tmp;
        if(a[m].x < 0.0) a[m + 1].x = a[m].x + pi * 2.0, a[m].x = 0, a[++ m].y = pi * 2.0;
        else if(a[m].y > pi * 2) a[m + 1].y = a[m].y - pi * 2, a[m].y = pi * 2, a[++ m].x = 0;
    }
    sort(a + 1, a + m + 1);
    L = a[1].x, RR = a[1].y;
    for(int i = 2;i <= m;i ++) {
        if(a[i].x >= RR) ans += RR - L, L = a[i].x, RR = a[i].y;
        else RR = max(RR, a[i].y);  
    }
    ans += RR - L;
    printf("%lf", abs(ans / (pi * 2)));
    return 0;
}

 

K.sightseeing

貌似高中做过的一个01规划问题

所以很显然的想到二分，然后处理边，判负环

好吧认真的说。显然最后结果必然是一个简单的环(自己思考

然后假设最优路径上fun之和为sf，路径长度为sl

则最优解 ans = sf / sl

那么我们二分一个mid，并把所有边的边长都设为 原长 * mid - fun[to]

若能找到负环，则存在sl * mid - sf <= 0

即mid <= sf / sl ，即 ans >= mid

所以二分就解释清楚了

至于判负环，dfs的spfa效率我不清楚

我用的bfs的spfa判负环，进队次数 >= n 即有负环

注意像我那么写的话，每次spfa开始要同时开始清理上次残留的队列以及visit数组！

#include <queue>
#include <cstdio> 
#include <vector>
#include <cstring>

using namespace std;

const int maxn = 1010;
const double eps = 1e-4;

int n, m, c[maxn], f[maxn], vis[maxn];

double d[maxn];

queue <int> q;

vector <double> E[maxn];
vector <pair<int, double> > e[maxn];

bool spfa() {
    while(!q.empty()) vis[q.front()] = 0, q.pop();
    static int u, v;
    static double w;
    for(int i = 2;i <= n;i ++)
        c[i] = 0, d[i] = 111111111;
    q.push(1), c[1] = 0;
    while(!q.empty()) {
        u = q.front();
        q.pop(), vis[u] = 0, c[u] ++;
        if(c[u] == n) return 1;
        for(int i = 0;i < e[u].size();i ++) {
            w = e[u][i].second, v = e[u][i].first;
            if(d[u] + w <= d[v]) {
                d[v] = d[u] + w;
                if(!vis[v]) vis[v] = 1, q.push(v);
            }
        }
    }
    return 0;
}

bool judge(double x) {
    for(int i = 1;i <= n;i ++)
        for(int j = 0;j < e[i].size();j ++) 
            e[i][j].second = x * E[i][j] - 1.0 * f[e[i][j].first];
    return spfa();
}

int main() {
    int u, v, w;
    scanf("%d %d", &n, &m);
    for(int i = 1;i <= n;i ++)
        scanf("%d", &f[i]);
    for(int i = 1;i <= m;i ++) {
        scanf("%d %d %d", &u, &v, &w);
        e[u].push_back(make_pair(v, w));
        E[u].push_back(w);
    }
    double l = 0.0, r = 1000.0, mid, ans = 0.0;
    while(l + eps <= r) {
        mid = (l + r) / 2.0;
        if(judge(mid)) l = mid + eps, ans = mid;
        else r = mid - eps;
    }
    printf("%.2f", ans);
    return 0;
}

 

L.ZS and The Birthday Paradox

好吧这个题我也是看题解做出来的

其实最原始的公式很好推

然后我们需要对结果x/y约分后

分子分母再对mod=1e6+3取模

利用乘法逆元可知若有gcd(x,y)=z

我们求得z对mod的逆元

就可以直接x，y对mod取模

再分别乘以z对mod的逆元，再对mod取模即可

根据原始公式有y = 2^(nk)

x = (2^n)(2^n - 1)(2^n - 2)...(2^n - k + 1)

虽然x有k项，但是我们只需要求x % mod 

x中的k项又是连续的，所以当 k >= mod时

一定会有x % mod = 0

k < mod时，直接暴力求x % mod 就行

到这里我们只需要考虑怎么求z了

显然z必然是2^i

求i的话，就是求(2^n - 1)(2^n - 2)...(2^n - k + 1)总共含多少个2

其实就是求(k - 1)! 中有多少个2

这里就能求i了

至此基本解决，再不懂看代码

#include <cstdio>

typedef long long ll;

const ll _mod = 1000003;

ll qow(ll x, ll k) {
    static ll y;
    x %= _mod, y = 1;
    for(;k > 0;k >>= 1, x = x * x % _mod)
        if(k & 1) y = x * y % _mod;
    return y;
}

int main() {
    ll n, k, fz, fm, tmp1, tmp2, tmp3;
    scanf("%I64d %I64d", &n, &k);
    if(n <= 60 && (1ll << n) < k) {
        puts("1 1");
        return 0;
    }
    fz = 1, tmp1 = qow(2, n);
    for(ll i = 0;i < k;i ++) {
        fz = fz * (tmp1 - i) % _mod;
        if(!fz) break;
    }
    fm = qow(tmp1, k), tmp2 = n, k --;
    while(k) k >>= 1, tmp2 += k;
    tmp3 = qow(2, tmp2), tmp3 = qow(tmp3, _mod - 2);
    fz = fz * tmp3 % _mod;
    fm = fm * tmp3 % _mod;
    fz = (fm - fz) % _mod;
    if(fz < 0) fz += _mod;
    printf("%I64d %I64d\n", fz, fm);
    return 0;
}

 

M.Vasiliy's Multiset

codeforces做过的原题

简单的二进制数的trie树

我写的指针+递归的确丑的没话说

注意!set里始终有0这个元素

所以要一开始手动插入0这个元素

尤其用指针不注意的话直接RE

#include <cstdio>

struct node {
    int num;
    node *c[2];
    node() {
        num = 0;
        c[0] = c[1] =NULL;
    }
}; 

void insert(node *&o, int x, int k) {
    if(o == NULL) o = new node;
    o->num ++;
    if(k == -1) return;
    insert(o->c[(x & (1 << k)) != 0], x, k - 1);
}

void erase(node *&o, int x, int k) {
    o->num --;
    if(k == -1) return;
    erase(o->c[(x & (1 << k)) != 0], x, k - 1);
}

void ask(node *&o, int x, int k, int ans) {
    if(k == -1) {
        printf("%d\n", ans);
        return;
    }
    int d = !(x & (1 << k));
    if(o->c[d] != NULL && o->c[d]->num != 0) ask(o->c[d], x, k - 1, ans | (1 << k));
    else ask(o->c[!d], x, k - 1, ans);
}

int main() {
    int n, m;
    char str[3];
    node *root = NULL;
    insert(root, 0, 30);
    scanf("%d", &n);
    while(n --) {
        scanf("%s %d", str, &m);
        switch(str[0]) {
            case '+':insert(root, m, 30);break;
            case '-':erase(root, m, 30);break;
            case '?':ask(root, m, 30, 0);break;
        }
    }
    return 0;
}