Codeforces Round #470

A. Protect Sheep 

题解：如果W与S不相邻，就在W的上下左右放上D。注意不能让D覆盖了W，如：WWD

/*
* Author:  Plumrain
* Created Time:  2013-11-11 15:38
* File Name: DP-CF-148D.cpp
*/
#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 100005;

int n, m;
char map[505][505];
int dx[] = { 0,1,0,-1 }, dy[] = { 1,0,-1,0 };

int main()
{
    while (scanf("%d%d", &n, &m) != EOF) {
        memset(map, 0, sizeof(map));
        for (int i = 0; i < n; i++) scanf("%s", map[i]);
        bool flag = true;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (map[i][j] == 'W') {
                    for (int k = 0; k < 4; k++) {
                        int mx = dx[k] + i, my = dy[k] + j;
                        if (mx < 0 || mx >= n || my < 0 || my >= m || map[mx][my] == 'W') continue;
                        if (map[mx][my] == 'S') { flag = false; break; }
                        map[mx][my] = 'D';
                    }
                }
                if (!flag) break;
            }
            if (!flag) break;
        }
        if (!flag) cout << "No" << endl;
        else {
            cout << "Yes" << endl;
            for (int i = 0; i <= n; i++) printf("%s\n", map[i]);
        }
    }
}

 

B. Primal Sport

#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 1e6 + 10;

int n, ans;
int p[maxn];

int main()
{
    while (scanf("%d", &n) != EOF) {
        ans = n;
        for (int i = 2; i <= n; i++) {
            if (!p[i]) for (int j = 2 * i; j <= n; j += i) p[j] = i;
            p[i] = i - p[i] + 1;
        }
        for (int i = p[n]; i <= n; i++) ans = min(ans, p[i]);
        printf("%d\n", ans);
    }
    return 0;
}

 

C. Producing Snow

题解：构造这样一个数列

还有一种是用二分查找pile消失在哪一天。

#pragma warning(disable:4996)
#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;

const int maxn = 1e5 + 5;

int n, a[maxn];

priority_queue<ll, vector<ll>, greater<ll> > q;

int main()
{
    while (scanf("%d", &n) != EOF) {
        while (!q.empty()) q.pop();
        for (int i = 1; i <= n; i++) scanf("%I64d", a + i);
        ll sum = 0, ans = 0, x;
        for (int i = 1; i <= n; i++) {
            scanf("%lld", &x);
            q.push((ll)a[i] + sum);
            while (q.top() <= sum + x && !q.empty()) { ans += (q.top() - sum); q.pop(); }
            ans += (ll)q.size()*x;
            sum += x;
            printf("%I64d\n", ans);
            ans = 0;
        }
    }
    return 0;
}

 二分查找+树状数组

#pragma warning(disable:4996)
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;

const int maxn = 1e5 + 5;

int n, a[maxn], b[maxn], bit[maxn];
ll sum[maxn], ans[maxn];

void Update(int i, int x) {
    while (i <= n) {
        bit[i] += x;
        i += i & -i;
    }
}

int Query(int i) {
    int s = 0;
    while (i > 0) {
        s += bit[i];
        i -= i & -i;
    }
    return s;
}

int main()
{    
    while (scanf("%d", &n) != EOF) {
        sum[0] = 0;
        memset(bit, 0, sizeof(bit));
        memset(ans, 0, sizeof(ans));
        for (int i = 1; i <= n; i++) scanf("%d", a + i);
        for (int i = 1; i <= n; i++) {
            scanf("%d", b + i);
            sum[i] = sum[i - 1] + b[i];
        }
        for (int i = 1; i <= n; i++) {
            int p = lower_bound(sum + i, sum + n + 1, a[i] + sum[i - 1]) - (sum);
            if (p > n) p = n;
            if (i < p) {
                Update(i, 1);
                Update(p,-1);
            }
            if (i <= p) {
                if (a[i] + sum[i - 1] > sum[p]) ans[p] += b[p];
                else ans[p] += (a[i] - sum[p - 1] + sum[i - 1]);
            }
        }
        for (int i = 1; i <= n; i++) {
            ans[i] += 1LL * b[i] * Query(i);
            printf("%I64d%c", ans[i], i == n ? '\n' : ' ');
        }
    }
    return 0;
}

 D. Perfect Security

Alice has a very important message M consisting of some non-negative integers that she wants to keep secret from Eve. Alice knows that the only theoretically secure cipher is one-time pad. Alice generates a random key K of the length equal to the message's length. Alice computes the bitwise xor of each element of the message and the key (, where denotes the bitwise XOR operation) and stores this encrypted message A. Alice is smart. Be like Alice.

For example, Alice may have wanted to store a message M = (0, 15, 9, 18). She generated a key K = (16, 7, 6, 3). The encrypted message is thus A = (16, 8, 15, 17).

Alice realised that she cannot store the key with the encrypted message. Alice sent her key K to Bob and deleted her own copy. Alice is smart. Really, be like Alice.

Bob realised that the encrypted message is only secure as long as the key is secret. Bob thus randomly permuted the key before storing it. Bob thinks that this way, even if Eve gets both the encrypted message and the key, she will not be able to read the message. Bob is not smart. Don't be like Bob.

In the above example, Bob may have, for instance, selected a permutation (3, 4, 1, 2) and stored the permuted key P = (6, 3, 16, 7).

One year has passed and Alice wants to decrypt her message. Only now Bob has realised that this is impossible. As he has permuted the key randomly, the message is lost forever. Did we mention that Bob isn't smart?

Bob wants to salvage at least some information from the message. Since he is not so smart, he asks for your help. You know the encrypted message A and the permuted key P. What is the lexicographically smallest message that could have resulted in the given encrypted text?

More precisely, for given A and P, find the lexicographically smallest message O, for which there exists a permutation π such that for every i.

Note that the sequence S is lexicographically smaller than the sequence T, if there is an index i such that S_i < T_i and for all j < i the condition S_j = T_j holds.

Input

The first line contains a single integer N (1 ≤ N ≤ 300000), the length of the message.

The second line contains N integers A₁, A₂, ..., A_N (0 ≤ A_i < 2³⁰) representing the encrypted message.

The third line contains N integers P₁, P₂, ..., P_N (0 ≤ P_i < 2³⁰) representing the permuted encryption key.

Output

Output a single line with N integers, the lexicographically smallest possible message O. Note that all its elements should be non-negative.

Examples

Input

Copy

3
8 4 13
17 2 7

Output

10 3 28

Input

Copy

5
12 7 87 22 11
18 39 9 12 16

Output

0 14 69 6 44

Input

Copy

10
331415699 278745619 998190004 423175621 42983144 166555524 843586353 802130100 337889448 685310951
226011312 266003835 342809544 504667531 529814910 684873393 817026985 844010788 993949858 1031395667

Output

128965467 243912600 4281110 112029883 223689619 76924724 429589 119397893 613490433 362863284

Note

In the first case, the solution is (10, 3, 28), since , and . Other possible permutations of key yield messages (25, 6, 10), (25, 3, 15), (10, 21, 10), (15, 21, 15) and (15, 6, 28), which are all lexicographically larger than the solution.

题意：A数组和P数组异或后得到新的序列的字典序要最小，注意P数组中的每一个数只能用一次。

题解：很长的题目啊~~~这里需要转一个弯，为了字典序最小，则 a[ i ] 每次异或得到的值就要最小，所以就用上了01字典树。

#pragma warning(disable:4996)
#include<cstdio>
#include<bitset>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int N = 33;
const int maxn = 300005;

struct node {
    int num,t;            // t 是为了计数，当t=0时说明这个节点已经被删除了!!!!!!!!! 
    node* next[2];
    node() {
        t = num = 0;
        memset(next, 0, sizeof(next));
    }
};

node* root = NULL;

void Build(int n) {
    bitset<N> bit = n;
    node* rt = root;
    for (int i = 32; i >= 0; i--) {
        int id = bit[i];
        if (!rt->next[id]) {
            node* tem = new node();
            rt->next[id] = tem;
            rt = tem;
        }
        else rt = rt->next[id];
        rt->t ++;
    }
    rt->num = n;
}

int Query(int m) {
    bitset<N> bit = m;
    node* rt = root;
    for (int i = 32; i >= 0; i--) {
        int id = bit[i];
        if (rt->next[id] && rt->next[id]->t != 0) {
            rt = rt->next[id];
            rt->t--;
        }
        else {
            rt = rt->next[id ^ 1];
            rt->t--;
        }
    }
    return rt->num;
}

void del(node* root) {
    for (int i = 0; i < 2; i++) if (root->next[i]) del(root->next[i]);
    delete root;
}

int a[maxn];

int main()
{
    int n;
    while (scanf("%d", &n) != EOF) {
        root = new node();
        for (int i = 1; i <= n; i++) scanf("%d", a + i);
        for (int i = 1; i <= n; i++) {
            int temp;
            scanf("%d", &temp);
            Build(temp);
        }
        for (int i = 1; i <= n; i++) printf("%d\n", a[i] ^ (Query(a[i])));
        del(root);             //一定要删除整棵树啊，因为是new出来的
    }
    return 0;
}