2017 Multi-University Training Contest - Team 1

半面数学 半面卡常

 

1001 Add More Zero

水题不写。

 

1002 Balala Power!

贪心，注意0不能首位。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int maxn = 2e5 + 10;
int d[26][maxn], sz[26], fir[26], id[26], vis[26];
char s[maxn];

bool larger(int i, int j)
{
    if(sz[i] > sz[j]) return true;
    if(sz[i] < sz[j]) return false;
    for(int k = sz[i]; k >= 0; k--)
        if(d[i][k] != d[j][k]) return d[i][k] > d[j][k];
    return false;
}

int main(void)
{
    int n, kase = 0;
    while(~scanf("%d", &n))
    {
        memset(d, 0, sizeof(d));
        memset(sz, 0, sizeof(sz));
        memset(fir, 0, sizeof(fir));
        memset(vis, 0, sizeof(vis));
        memset(id, -1, sizeof(id));
        for(int i = 1; i <= n; i++)
        {
            scanf("%s", s + 1);
            int l = strlen(s + 1);
            if(l != 1) fir[s[1]-'a'] = 1;
            for(int j = l; j; j--)
            {
                d[s[j]-'a'][l-j]++;
                sz[s[j]-'a'] = max(sz[s[j]-'a'], l-j);
                vis[s[j]-'a'] = 1;
            }
        }
        for(int c = 0; c < 26; c++)
            for(int i = 0; i <= sz[c]; i++)
                if(d[c][i] >= 26) d[c][i+1] += d[c][i] / 26, d[c][i] %= 26, sz[c] = max(sz[c], i + 1);
        int cnt = 0;
        for(int i = 0; i < 26; i++) cnt += vis[i];
        if(cnt == 26)
        {
            int p = -1;
            for(int i = 0; i < 26; i++)
            {
                if(fir[i]) continue;
                if(p == -1 || larger(p, i)) p = i;
            }
            id[p] = 0;
            for(int i = 1; i <= 25; i++)
            {
                p = -1;
                for(int j = 0; j < 26; j++)
                {
                    if(id[j] != -1) continue;
                    if(p == -1 || larger(p, j)) p = j;
                }
                id[p] = i;
            }
        }
        else
        {
            for(int i = 25; i >= 26 - cnt; i--)
            {
                int p = -1;
                for(int j = 0; j < 26; j++)
                {
                    if(id[j] != -1) continue;
                    if(p == -1 || larger(j, p)) p = j;
                }
                id[p] = i;
            }
        }
        LL ans = 0;
        for(int i = 0; i < 26; i++)
        {
            if(!vis[i]) continue;
            LL base = 1;
            for(int j = 0; j <= sz[i]; j++) ans = (ans + id[i] * base % mod * d[i][j]) % mod, base = base * 26 % mod;
        }
        printf("Case #%d: %lld\n", ++kase, ans);
    }
    return 0;
}

 

1003 Colorful Tree

其实和虚树没什么关系 考虑统计不经过颜色c的路径 端点一定在一些联通块里

对于一个颜色c的节点 遍历子树时把遇到的含有颜色c的子树扣掉就是这个联通块的大小

但是还需要注意的是还会有一个包含root的联通块要单独考虑

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <unordered_map>
#include <stack>
using namespace std;
typedef long long LL;
const int maxn = 2e5 + 10;
int vis[maxn], c[maxn];
unordered_map< int, stack<int> > st;

int cnt, h[maxn];
struct edge
{
    int to, pre;
} e[maxn<<1];
void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

LL ans;
int sz[maxn], num[maxn], rt[maxn];
void dfs(int x, int f)
{
    st[c[x]].push(x);
    sz[x] = 1, num[x] = 0;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f) continue;
        dfs(to, x);
        sz[x] += sz[to];
        ans -= (LL) (sz[to] - num[x]) * (sz[to] - num[x] - 1) / 2;
        num[x] = 0;
    }
    st[c[x]].pop();
    if(st[c[x]].empty()) rt[c[x]] += sz[x];
    else num[st[c[x]].top()] += sz[x];
}

int main(void)
{
    int n, kase = 0;
    while(~scanf("%d", &n))
    {
        st.clear();
        cnt = 0;
        for(int i = 1; i <= n; i++) h[i] = vis[i] = rt[i] = 0;
        for(int i = 1; i <= n; i++) scanf("%d", c + i), vis[c[i]] = 1;
        for(int i = 1; i < n; i++)
        {
            int u, v;
            scanf("%d %d", &u, &v);
            add(u, v), add(v, u);
        }
        ans = 0;
        dfs(1, 0);
        for(int i = 1; i <= n; i++) if(vis[i]) ans += (LL) n * (n - 1) / 2 - (LL) (sz[1] - rt[i]) * (sz[1] - rt[i] - 1) / 2;
        printf("Case #%d: %lld\n", ++kase, ans);
    }
    return 0;
}

场上卡了很久的点分治，大概是每次直接统计经过当前根rt的边的贡献

需要算哪些颜色贡献计算一次，哪些计算两次

遍历次数比较多，加读入挂才过

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

// fastIO
namespace fastIO {
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if(p1 == pend) {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pend == p1) {
                IOerror = 1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }
    inline void read(int &x) {
        char ch;
        while(blank(ch = nc()));
        if(IOerror)
            return;
        for(x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
    }
    #undef BUF_SIZE
};
using namespace fastIO;

typedef long long LL;
const int maxn = 2e5 + 10;
int vis[maxn], c[maxn];

// edge
int cnt, h[maxn];
struct edge
{
    int to, pre;
} e[maxn<<1];

void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

// tree
int sz[maxn];
void Size(int x, int f)
{
    sz[x] = 1;
    int tmp = 0;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to]) continue;
        Size(to, x);
        sz[x] += sz[to];
    }
}

int rt, M;
void Root(int r, int x, int f)
{
    int tmp = 0;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to]) continue;
        Root(r, to, x);
        tmp = max(tmp, sz[to]);
    }
    tmp = max(tmp, sz[r] - sz[x]);
    if(tmp < M) M = tmp, rt = x;
}

LL ans;
int num[maxn];
void dfs(int x, int rt, int f)
{
    sz[x] = 1;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to]) continue;
        dfs(to, rt, x);
        sz[x] += sz[to];
    }
    if(f == rt) ans += (LL) sz[x] * sz[rt];
}

int c_sz[maxn];
void dfs1(int x, int szr, int f)
{
    num[c[x]]++;
    if(num[c[x]] == 1) ans += (LL) sz[x] * (szr - c_sz[c[x]]);
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to]) continue;
        dfs1(to, szr, x);
    }
    num[c[x]]--;
}
void dfs2(int x, int f)
{
    num[c[x]]++;
    if(num[c[x]] == 1) c_sz[c[x]] += sz[x];
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to]) continue;
        dfs2(to, x);
    }
    num[c[x]]--;
}
void dfs3(int x, int f)
{
    num[c[x]]++;
    if(num[c[x]] == 1) c_sz[c[x]] -= sz[x];
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to]) continue;
        dfs3(to, x);
    }
    num[c[x]]--;
}

void solve(int x)
{
    M = maxn;
    Size(x, 0);
    Root(x, x, 0);
    vis[rt] = 1;

    dfs(rt, rt, 0);
    num[c[rt]]++;
    for(int i = h[rt]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(vis[to]) continue;
        dfs1(to, sz[rt] - sz[to], rt);
        dfs2(to, rt);
    }
    for(int i = h[rt]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(vis[to]) continue;
        dfs3(to, rt);
    }
    num[c[rt]]--;

    for(int i = h[rt]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(vis[to]) continue;
        solve(to);
    }
}

int main(void)
{
    // int size = 256 << 20; // 256MB
    // char *p = (char*)malloc(size) + size;
    // __asm__("movl %0, %%esp\n" :: "r"(p));

    // freopen("data.txt", "r", stdin);
    // freopen("ygy.txt", "w", stdout);

    int n, kase = 0;
    while(read(n), !IOerror)
    {
        for(int i = 1; i <= n; i++) read(c[i]);
        cnt = 0;
        for(int i = 1; i <= n; i++) h[i] = vis[i] = 0;
        for(int i = 1; i < n; i++)
        {
            int u, v;
            read(u), read(v);
            add(u, v), add(v, u);
        }
        ans = 0; solve(1);
        printf("Case #%d: %lld\n", ++kase, ans);
    }
    return 0;
}

 

1004 Division Game

1005 Expectation Division

1006 Function

观察到置换分解后只能映射到因子长度的环上

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
typedef long long LL;
const LL mod = 1e9 + 7;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int visa[maxn], visb[maxn];
int numa[maxn], numb[maxn];
vector<int> fac[maxn];

int main(void)
{
    for(int i = 1; i < maxn; i++)
        for(int j = i; j < maxn; j += i)
            fac[j].push_back(i);
    int n, m, kase= 0;
    while(~scanf("%d %d", &n, &m))
    {
        for(int i = 0; i < n; i++) scanf("%d", a + i);
        for(int i = 0; i < m; i++) scanf("%d", b + i);
        memset(visa, 0, sizeof(visa));
        memset(visb, 0, sizeof(visb));
        memset(numa, 0, sizeof(numa));
        memset(numb, 0, sizeof(numb));
        for(int i = 0; i < n; i++)
        {
            if(visa[i]) continue;
            int p = i, cnt = 0;
            while(!visa[p]) visa[p] = 1, cnt++, p = a[p];
            numa[cnt]++;
        }
        for(int i = 0; i < m; i++)
        {
            if(visb[i]) continue;
            int p = i, cnt = 0;
            while(!visb[p]) visb[p] = 1, cnt++, p = b[p];
            numb[cnt]++;
        }
        LL ans = 1;
        for(int i = 1; i <= n; i++)
        {
            if(!numa[i]) continue;
            LL tmp = 0;
            for(int j = 0; j < fac[i].size(); j++) tmp = (tmp + (LL) numb[fac[i][j]] * fac[i][j]) % mod;
            for(int j = 0; j < numa[i]; j++) ans = ans * tmp % mod;
        }
        printf("Case #%d: %lld\n", ++kase, ans);
    }
    return 0;
}

 

1007 Gear Up

不好写……

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 1e5 + 10;
const int INF = 1e9;
vector<int> vec[maxn];

int log2(int x)
{
    int cnt = 0;
    while(x >= 2) x >>= 1, cnt++;
    return cnt;
}

// edge
int cnt, h[maxn];
struct edge
{
    int to, pre;
} e[maxn<<1];
void add(int from, int to)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    h[from] = cnt;
}

// UF
int fa[maxn];
int Find(int x)
{
    return fa[x] == x ? x : fa[x] = Find(fa[x]);
}
void Union(int x, int y)
{
    x = Find(x);
    y = Find(y);
    if(x != y) fa[y] = x;
}

// dfs
int dfs_clock;
int r[maxn], w[maxn];
int vis[maxn], op[maxn], rt[maxn];
int L1[maxn], R1[maxn], L2[maxn], R2[maxn], rl[maxn], rr[maxn];
void dfs(int x, int o, int root)
{
    rt[x] = root;
    L2[x] = ++dfs_clock;
    int ww = w[dfs_clock];
    vis[x] = 1, op[x] = o;
    vector<int> tmp = vec[Find(x)];
    vec[Find(x)].clear();
    int sz = tmp.size();
    for(int i = 0; i < sz; i++)
    {
        int to = tmp[i];
        if(to == x) continue;
        w[dfs_clock + 1] = ww, dfs(to, 2, root);
    }
    R2[x] = dfs_clock, L1[x] = R2[x] + 1;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(vis[to]) continue;
        w[dfs_clock + 1] = ww + r[x] - r[to], dfs(to, 1, root);
    }
    R1[x] = dfs_clock;
}

// seg
int M[maxn<<2], tag[maxn<<2];
void gather(int p)
{
    M[p] = max(M[p<<1], M[p<<1|1]);
}
void push(int p)
{
    if(tag[p])
    {
        tag[p<<1] += tag[p];
        tag[p<<1|1] += tag[p];
        M[p<<1] += tag[p];
        M[p<<1|1] += tag[p];
        tag[p] = 0;
    }
}
void build(int p, int l, int r)
{
    tag[p] = 0;
    if(l < r)
    {
        int mid = (l + r) >> 1;
        build(p<<1, l, mid);
        build(p<<1|1, mid + 1, r);
        gather(p);
    }
    else M[p] = w[l];
}
void modify(int p, int tl, int tr, int l, int r, int v)
{
    if(tl > tr) return;
    if(tr < l || r < tl) return;
    if(l <= tl && tr <= r)
    {
        tag[p] += v;
        M[p] += v;
        return;
    }
    push(p);
    int mid = (tl + tr) >> 1;
    modify(p<<1, tl, mid, l, r, v);
    modify(p<<1|1, mid+1, tr, l, r, v);
    gather(p);
}
int query(int p, int tl, int tr, int l, int r)
{
    if(tl > tr) return -INF;
    if(tr < l || r < tl) return -INF;
    if(l <= tl && tr <= r) return M[p];
    push(p);
    int mid = (tl + tr) >> 1;
    return max(query(p<<1, tl, mid, l, r), query(p<<1|1, mid+1, tr, l, r));
}

int main(void)
{
    int n, m, q, kase = 0;
    while(~scanf("%d %d %d", &n, &m, &q))
    {
        for(int i = 1; i <= n; i++)
        {
            int x;
            scanf("%d", &x);
            r[i] = log2(x);
        }
        cnt = dfs_clock = 0;
        for(int i = 1; i <= n; i++) vis[i] = h[i] = 0, fa[i] = i;
        for(int i = 1; i <= m; i++)
        {
            int a, x, y;
            scanf("%d %d %d", &a, &x, &y);
            if(a == 1) add(x, y), add(y, x);
            else Union(x, y);
        }
        for(int i = 1; i <= n; i++) vec[Find(i)].push_back(i);
        for(int i = 1; i <= n; i++)
            if(!vis[i]) w[dfs_clock + 1] = 0, rl[i] = dfs_clock + 1, dfs(i, 0, i), rr[i] = dfs_clock;
        build(1, 1, n);
        printf("Case #%d:\n", ++kase);
        while(q--)
        {
            int a, x, y;
            scanf("%d %d %d", &a, &x, &y), y = log2(y);
            if(a == 1)
            {
                if(op[x] % 2) modify(1, 1, n, L2[x], R2[x], r[x] - y);
                else modify(1, 1, n, L1[x], R1[x], y - r[x]);
                r[x] = y;
            }
            else printf("%.3f\n", log(2) * (y + query(1, 1, n, rl[rt[x]], rr[rt[x]]) - query(1, 1, n, L2[x], L2[x])));
        }
    }
    return 0;
}

 

1008 Hints of sd0061

NthElement 实现上是类似快排 由于只递归一边所以期望on

按询问从大到小做 不同的询问不多 每次排的长度递减 据说就on了

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
using namespace std;

unsigned a[10000010];
// Nth_element
int Partition(unsigned a[], int l, int r)
{
    int rd = l + (long long) rand() * 10007 % (r - l + 1);
    swap(a[rd], a[r]);
    int j = l - 1;
    for(int i = l; i < r; i++) if(a[i] <= a[r]) swap(a[++j], a[i]);
    swap(a[++j], a[r]);
    return j;
}
int NthElement(unsigned a[], int l, int r, int id)
{
    if(l == r) return a[l];
    int m = Partition(a, l, r), cur = m - l + 1;
    if(id == cur) return a[m];
    if(id < cur) return NthElement(a, l, m - 1, id);
    return NthElement(a, m + 1, r, id - cur);
}

// rand
unsigned x, y, z;
unsigned rng61() {
  unsigned t;
  x ^= x << 16;
  x ^= x >> 5;
  x ^= x << 1;
  t = x;
  x = y;
  y = z;
  z = t ^ x ^ y;
  return z;
}

int q[222], p[222], ans[222];
bool cmp(int i, int j)
{
    return q[i] > q[j];
}

int main(void)
{
    unsigned A, B, C;
    int n, m, kase = 0;
    while(~scanf("%d %d %u %u %u", &n, &m, &A, &B, &C))
    {
        for(int i = 1; i <= m; i++) scanf("%d", q + i), p[i] = i;
        x = A, y = B, z = C;
        for(int i = 1; i <= n; i++) a[i] = rng61();
        sort(p + 1, p + 1 + m, cmp);
        int mi = n;
        for(int i = 1; i <= m; i++)
        {
            if(i > 1 && q[p[i]] == q[p[i-1]]) ans[p[i]] = ans[p[i-1]];
            else
            {
                ans[p[i]] = NthElement(a, 1, mi, q[p[i]] + 1);
                mi = q[p[i]] + 1;
            }
        }
        printf("Case #%d:", ++kase);
        for(int i = 1; i <= m; i++) printf(" %u", ans[i]); puts("");
    }
    return 0;
}

 

1009 I Curse Myself

仙人掌环抠出来 k路归并

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
int k;

// edge
int cnt, h[1111];
struct edge
{
    int to, pre, v;
} e[4444];
void add(int from, int to, int v)
{
    cnt++;
    e[cnt].pre = h[from];
    e[cnt].to = to;
    e[cnt].v = v;
    h[from] = cnt;
}

bool cmp(int i, int j)
{
    return i > j;
}

// loop
int vis[1111], fa[1111], fae[1111], num;
vector<int> seq[1111];
void dfs(int x, int f, int eid)
{
    vis[x] = 1, fa[x] = f; fae[x] = eid;
    for(int i = h[x]; i; i = e[i].pre)
    {
        int to = e[i].to;
        if(to == f || vis[to] == 2) continue;
        if(vis[to] == 1)
        {
            seq[++num].clear();
            seq[num].push_back(e[i].v);
            int tmp = x;
            while(tmp != to)
            {
                seq[num].push_back(e[fae[tmp]].v);
                tmp = fa[tmp];
            }
            sort(seq[num].begin(), seq[num].end(), cmp);
        }
        else dfs(to, x, i);
    }
    vis[x] = 2;
}

vector<int> ret;

struct PQ
{
    piii a[222222];
    int tail;
    PQ(){tail = 0;}
    void push(piii cur)
    {
        a[++tail] = cur;
        int p = tail;
        while(p > 1)
        {
            if(a[p] > a[p/2]) swap(a[p], a[p/2]), p /= 2;
            else break;
        }
    }
    piii top()
    {
        return a[1];
    }
    void pop()
    {
        a[1] = a[tail--];
        int p = 1;
        while(p <= tail)
        {
            if(p + p <= tail && a[p] < a[p+p] && (p + p + 1 > tail || a[p+p] > a[p+p+1])) swap(a[p], a[p+p]), p *= 2;
            else if(p + p + 1 <= tail && a[p] < a[p+p+1]) swap(a[p], a[p+p+1]), p = p + p + 1;
            else break;
        }
    }
    bool empty()
    {
        return tail == 0;
    }
} pq;

void Merge(vector<int> & ans, vector<int> & nxt)
{
    int sza = ans.size(), szn = nxt.size();
    pq.tail = 0;
    ret.resize(0);
    for(int i = 0; i < szn; i++) pq.push(piii(ans[0] + nxt[i], pii(0, i)));
    while(ret.size() < k && !pq.empty())
    {
        piii tmp = pq.top(); pq.pop();
        ret.push_back(tmp.first);
        if(tmp.second.first + 1 < sza) pq.push(piii(ans[tmp.second.first+1] + nxt[tmp.second.second], pii(tmp.second.first + 1, tmp.second.second)));
    }
    ans = ret;
}

int main(void)
{
    // freopen("1009.in", "r", stdin);
    // freopen("ygy.txt", "w", stdout);

    int n, m, kase = 0;
    while(~scanf("%d %d", &n, &m))
    {
        int sum = cnt = 0;
        for(int i = 1; i <= n; i++) h[i] = 0, vis[i] = 0;
        for(int i = 1; i <= m; i++)
        {
            int x, y, z;
            scanf("%d %d %d", &x, &y, &z);
            sum += z, add(x, y, z), add(y, x, z);
        }
        scanf("%d", &k);

        num = 0, dfs(1, 0, 0);
        vector<int> ans = seq[1];
        for(int i = 2; i <= num; i++) Merge(ans, seq[i]);

        unsigned int ret = 0, sza = ans.size();
        if(!num) ret += sum;
        else for(int i = 0; i < sza; i++) ret += (i + 1) * (sum - ans[i]);
        printf("Case #%d: %u\n", ++kase, ret);
    }
    return 0;
}

 

1010 Journey with Knapsack

1011 KazaQ's Socks

找找规律。

#include <iostream>
#include <cstdio>
using namespace std;
typedef long long LL;

int main(void)
{
    int kase = 0;
    LL n, k;
    while(~scanf("%lld %lld", &n, &k))
    {
        LL q = (k - 1) / (n - 1), r = (k - 1) % (n - 1) + 1, ans;
        if(q == 0) ans = r;
        else if(q % 2) ans = r == 1 ? n : r - 1;
        else ans = r == 1 ? n - 1 : r - 1;
        printf("Case #%d: %lld\n", ++kase, ans);
    }
    return 0;
}

 

1012 Limited Permutation

加读入挂直接log就过了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;

// fastIO
namespace fastIO {
    #define BUF_SIZE 100000
    //fread -> read
    bool IOerror = 0;
    inline char nc() {
        static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
        if(p1 == pend) {
            p1 = buf;
            pend = buf + fread(buf, 1, BUF_SIZE, stdin);
            if(pend == p1) {
                IOerror = 1;
                return -1;
            }
        }
        return *p1++;
    }
    inline bool blank(char ch) {
        return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
    }
    inline void read(int &x) {
        char ch;
        while(blank(ch = nc()));
        if(IOerror)
            return;
        for(x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
    }
    #undef BUF_SIZE
};
using namespace fastIO;

typedef long long LL;
typedef pair<int, int> pii;
const LL mod = 1e9 + 7;
const int maxn = 1e6 + 10;
int l[maxn], r[maxn];
vector<pii> v[maxn];
LL inv[maxn], fac[maxn], ifac[maxn];

LL C(int a, int b)
{
    return fac[a] * ifac[b] % mod * ifac[a-b] % mod;
}

LL solve(int L, int R)
{
    if(L > R) return 1LL;
    pii now = v[L].back(); v[L].pop_back();
    if(now.first != R) return 0LL;
    return solve(L, now.second - 1) * solve(now.second + 1, R) % mod * C(R - L, now.second - L) % mod;
}

int main(void)
{
    fac[0] = ifac[0] = inv[1] = 1;
    for(int i = 2; i < maxn; i++) inv[i] = (mod - (mod / i) * inv[mod%i] % mod) % mod;
    for(int i = 1; i < maxn; i++) fac[i] = fac[i-1] * i % mod, ifac[i] = ifac[i-1] * inv[i] % mod;
    int n, kase = 0;
    while(read(n), !IOerror)
    {
        for(int i = 1; i <= n; i++) read(l[i]), v[i].clear();
        for(int i = 1; i <= n; i++) read(r[i]), v[l[i]].push_back(pii(r[i], i));
        for(int i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
        LL ans = solve(1, n);
        printf("Case #%d: %lld\n", ++kase, ans);
    }
    return 0;
}