2017 Chinese Multi-University Training, BeihangU Contest 部分题解

最新推荐文章于 2022-08-30 16:02:46 发布
最新推荐文章于 2022-08-30 16:02:46 发布
阅读量507 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Irving0323/article/details/113828001
版权

比赛链接

 

Problem A. Add More Zero

温暖的签到题。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    double m ;
    int cas = 0 ;
    while(cin >> m)
    {
        cout << "Case #" << ++ cas << ": " ;
        m *= log10(2) ;
        cout << (int)m << '\n' ;
    }
    return 0 ;
}

 

Problem B. Balala Power!

先把每个字符的权值都当成1，把每种字符的贡献算出来，然后按照贡献从大到小排序依次分配25,24,\cdots,0。

注意前导0。

#include<bits/stdc++.h>
using namespace std ;
const int mod = 1e9 + 7 ;
const int maxn = 1e5 + 1e4 + 10 ;
int cnt[30][maxn] ;
int mx[30] ;
bool vis[30] ;
int pre[maxn] ;
bool zero[30] ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n ;
    int cas = 0 ;
    pre[0] = 1 ;
    for(int i = 1 ; i <= 1e5 + 1e4 ; i ++)  pre[i] = 1ll * pre[i - 1] * 26 % mod ;
    while(cin >> n)
    {
        cout << "Case #" << ++ cas << ": " ;
        memset(cnt , 0 , sizeof(cnt)) ;
        memset(mx , -1 , sizeof(mx)) ;
        memset(vis , false , sizeof(vis)) ;
        memset(zero , false , sizeof(zero)) ;
        while(n --)
        {
            string s ;
            cin >> s ;
            int len = s.size() ;
            for(int i = 0 ; i < len ; i ++)
            {
                int p = len - 1 - i ;
                cnt[s[i] - 'a'][p] ++ ;
                mx[s[i] - 'a'] = max(mx[s[i] - 'a'] , p) ;
            }
            if(len > 1)  zero[s[0] - 'a'] = true ;
        }
        for(int i = 0 ; i < 26 ; i ++)
        {
            for(int j = 0 ; j <= mx[i] + 50 ; j ++)
            {
                cnt[i][j + 1] += cnt[i][j] / 26 ;
                cnt[i][j] %= 26 ; 
            }
            for(int j = mx[i] + 50 ; j >= 0 ; j --)
                if(cnt[i][j] > 0)  mx[i] = max(mx[i] , j) ;
        }
        vector<int> v ;
        int ans = 0 ;
        for(int i = 0 ; i < 26 ; i ++)
        {
            int id = -1 ;
            for(int j = 0 ; j < 26 ; j ++)
            {
                if(vis[j])  continue ;
                if(id == -1)
                {
                    id = j ;
                    continue ;
                }
                if(mx[j] < mx[id])  continue ;
                if(mx[j] > mx[id])
                {
                    id = j ;
                    continue ;
                }
                for(int k = mx[j] ; k >= 0 ; k --)
                {
                    if(cnt[j][k] > cnt[id][k])
                    {
                        id = j ;
                        break ;
                    }
                    else if(cnt[j][k] == cnt[id][k])  continue ;
                    else  break ;
                }
            }
            vis[id] = true ;
            v.push_back(id) ;
        }
        int t ;
        for(int i = 25 ; i >= 0 ; i --)
        {
            if(!zero[v[i]])
            {
                t = i ;
                break ;
            }
        }
        //cout << t << '\n' ;
        int tmp = v[t] ;
        for(int i = t ; i < 25 ; i ++)  v[i] = v[i + 1] ;
        v[25] = tmp ;
        for(int i = 0 ; i < 25 ; i ++)
        {
            int id = v[i] ;
            for(int j = 0 ; j <= mx[id] ; j ++)  
                ans += 1ll * cnt[id][j] * (25 - i) * pre[j] % mod , ans %= mod ;
        }
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

Problem C. Colorful Tree

考虑容斥，对于每种颜色，统计不包含该种颜色的路径数。

对于一个不包含第i种颜色的极大联通子图G，设G的大小是siz，答案减去C(siz,2)即可。

其实一个dfs就完事，具体细节看代码。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n ;
    int cas = 0 ;
    while(cin >> n)
    {
        cout << "Case #" << ++ cas << ": " ;
        vector<int> c(n + 1) ;
        for(int i = 1 ; i <= n ; i ++)  cin >> c[i] ;
        vector<vector<int>> g(n + 1) ; 
        for(int i = 1 ; i <= n - 1 ; i ++)
        {
            int u , v ;
            cin >> u >> v ;
            g[u].push_back(v) ;
            g[v].push_back(u) ;
        }
        long long ans = 1ll * n * n * (n - 1) / 2 ;
        vector<int> d(n + 1 , 0) ;
        vector<int> siz(n + 1 , 0) ;
        function<long long(int)> C = [&](int x)
        {
            return 1ll * x * (x - 1) / 2 ;
        } ;
        function<void(int , int)> dfs = [&](int fa , int u)
        {
            int tmp = d[c[u]] ;
            siz[u] = 1 ;
            for(auto v : g[u])
            {
                if(v == fa)  continue ;
                d[c[u]] = tmp ;   
                dfs(u , v) ;
                ans -= C(siz[v] - (d[c[u]] - tmp)) ;
                siz[u] += siz[v] ;
            }
            d[c[u]] = tmp + siz[u] ;
        } ;
        dfs(1 , 1) ;
        for(int i = 1 ; i <= n ; i ++)  ans -= C(n - d[i]) ;
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

Problem D. Division Game

留坑。

 

Problem E. Expectation of Division

留坑。

 

Problem F. Function

每个排列a中长度为l的环，都可以映射到b中长度是l的因子的环。累加贡献即可。

#include<bits/stdc++.h>
using namespace std ;
const int mod = 1e9 + 7 ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n , m ;
    int cas = 0 ;
    while(cin >> n >> m)
    {
        cout << "Case #" << ++ cas << ": " ;
        vector<int> a(n) ;
        vector<int> b(m) ;
        for(int i = 0 ; i < n ; i ++)  cin >> a[i] ;
        for(int i = 0 ; i < m ; i ++)  cin >> b[i] ;
        vector<bool> vis1(n , false) ;
        vector<bool> vis2(m , false) ;
        vector<int> cnt1(n + 1 , 0) ;
        vector<int> cnt2(m + 1 , 0) ;
        int cnt = 0 ;
        function<void(int)> dfs1 = [&](int u)
        {
            if(vis1[u])  return ;
            vis1[u] = true ;
            cnt ++ ;
            dfs1(a[u]) ;
        } ;
        for(int i = 0 ; i < n ; i ++)
            if(!vis1[i])  cnt = 0 , dfs1(i) , cnt1[cnt] ++ ;
        cnt = 0 ;
        function<void(int)> dfs2 = [&](int u)
        {
            if(vis2[u])  return ;
            vis2[u] = true ;
            cnt ++ ;
            dfs2(b[u]) ;
        } ;
        for(int i = 0 ; i < m ; i ++)
            if(!vis2[i])  cnt = 0 , dfs2(i) , cnt2[cnt] ++ ;
        vector<int> c(n + 1 , 0) ;
        for(int i = 1 ; i <= m ; i ++)
            for(int j = i ; j <= n ; j += i)
                c[j] += 1ll * cnt2[i] * i % mod , c[j] %= mod ;
        //for(int i = 1 ; i <= n ; i ++)  cout << i << ' ' << c[i] << '\n' ;
        bool flag = true ;
        long long ans = 1 ;
        for(int i = 1 ; i <= n ; i ++)
            if(cnt1[i] > 0)
            {
                //cout << i << ' ' << cnt1[i] << '\n' ;
                if(c[i] == 0)  flag = false ;
                else  for(int j = 1 ; j <= cnt1[i] ; j ++)  ans *= c[i] , ans %= mod ;
            }
        if(!flag)  ans = 0 ;
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

Problem G. Gear Up

这道题搞了好几个小时。刚开始题解半天看不懂啥意思，什么**父亲儿子角速度线速度的。

后来太烦了，手动画了几个图才搞明白是个啥，其实很简单。主要是要耐心画图。

本质是若干棵树组成的森林，每个节点其实是一个连通块，连通块内的齿轮角速度相同。边其实就代表着线速度相同。

每个连通块内的若干个节点会与父亲的连通块内节点和儿子的连通块内节点相连。具体关系需要手推了，说不清楚，题解其实说的也没法立刻明白啥意思。

主要考的是dfs序和线段树。不过外面套的壳太神了，需要耐心剥开。

#include<bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define sz(x)  (int)x.size()
#define cl(x)  x.clear()
#define all(x)  x.begin() , x.end()
#define rep(i , x , n)  for(int i = x ; i <= n ; i ++)
#define per(i , n , x)  for(int i = n ; i >= x ; i --)
#define mem0(x)  memset(x , 0 , sizeof(x))
#define mem_1(x)  memset(x , -1 , sizeof(x))
#define mem_inf(x)  memset(x , 0x3f , sizeof(x))
#define debug(x)  cerr << #x << " = " << x << '\n'
#define ddebug(x , y)  cerr << #x << " = " << x << "   " << #y << " = " << y << '\n'
#define ios std::ios::sync_with_stdio(false) , cin.tie(0)
using namespace std ;
typedef long long ll ;
typedef long double ld ;
typedef pair<int , int> pii ;
typedef pair<ll , ll> pll ;
typedef double db ;
const int mod = 998244353 ;
const int maxn = 1e5 + 10 ;
const int inf = 0x3f3f3f3f ;
const double eps = 1e-6 ;
int n , m , q ;
int r[maxn] ;
vector<int> g[maxn] ;
vector<int> c[maxn] ;
bool vis[maxn] ;
int p[maxn] ;
int cnt ;
int dfn[maxn] ;
int siz[maxn] ;
int anc[maxn] ;
int L[maxn] , R[maxn] ;
bool fa[maxn] ;
bool son[maxn] ;
int l1[maxn] , r1[maxn] ;
struct Dsu
{
    int pre[maxn] , siz[maxn] ;
    void init(int n)
    {
        for(int i = 1 ; i <= n ; i ++)  pre[i] = i , siz[i] = 1 ;
    }
    int find(int u) 
    {
        if(pre[u] == u)  return u ;
        return pre[u] = find(pre[u]) ;
    }
    void join(int x , int y)
    {
        int fx = find(x) ;
        int fy = find(y) ;
        if(fx != fy)  
        {
            if(siz[fx] <= siz[fy])  pre[fx] = fy , siz[fy] += siz[fx] ;
            else  pre[fy] = fx , siz[fx] += siz[fy] ;
        }       
    }
} dsu ;
struct seg_tree
{
    int max1[maxn << 2] , lazy[maxn << 2] ;  
    int ls(int x){ return x << 1 ; }
    int rs(int x){ return x << 1 | 1 ; }
    void push_up(int p){ max1[p] = max(max1[ls(p)] , max1[rs(p)]) ; }
    void build(int id , int l , int r)
    {
        lazy[id] = 0 ;
        if(l == r) {max1[id] = p[l] ; return ;}
        int mid = (l + r) >> 1 ;
        build(ls(id) , l , mid) ;
        build(rs(id) , mid + 1 , r) ;
        push_up(id) ;
    } 
    void f(int id , int l , int r , int k)
    {
        lazy[id] += k ;
        max1[id] += k ;
    }
    void push_down(int id , int l , int r)
    {
        int mid = (l + r) >> 1 ;
        f(ls(id) , l , mid , lazy[id]) ;
        f(rs(id) , mid + 1 , r , lazy[id]) ;
        lazy[id] = 0 ;
    }
    void add(int id , int l , int r , int x , int y , int k)
    {
        if(x > y || x > r || y < l)  return ;
        if(x <= l && r <= y)
        {
            max1[id] += k ;
            lazy[id] += k ;
            return ;
        }
        push_down (id , l , r) ;
        int mid = (l + r) >> 1 ;
        if(x <= mid)  add(ls(id) , l , mid , x , y , k) ;
        if(y > mid)   add(rs(id) , mid + 1 , r , x , y , k) ;
        push_up(id) ;
    }
    int query(int id , int l , int r , int x , int y)
    {
        if(x > y || x > r || y < l)  return inf ;
        int ans = -1e9 ;
        if(x <= l && r <= y) return max1[id] ; 
        int mid = (l + r) >> 1 ;
        push_down(id , l , r) ;
        if(x <= mid) ans = max(ans , query(ls(id) , l , mid , x , y)) ;
        if(y > mid)  ans = max(ans , query(rs(id) , mid + 1 , r , x , y)) ;
        return ans ;
    }
} seg ;
void dfs(int u , int val , int t)
{
    dfn[u] = ++ cnt ;
    p[dfn[u]] = val ;
    siz[dfn[u]] = 1 ;
    anc[u] = t ;
    L[u] = cnt ;
    for(auto x : c[u])
    {
        vis[x] = true ;
        for(auto v : g[x])
        {
            if(vis[v])  continue ;
            son[x] = true ;
            fa[v] = true ;
            l1[x] = min(l1[x] , cnt + 1) ;
            dfs(dsu.find(v) , val + r[x] - r[v] , t) ;
            //cout << "###  " << x << ' ' << L[x] << ' ' << R[x] << '\n' ;
            siz[dfn[u]] += siz[dfn[dsu.find(v)]] ;
            r1[x] = cnt ;
        }
    }
    R[u] = cnt ;
}
int main()
{
    ios ;
    int cas = 0 ;
    while(cin >> n >> m >> q)
    {
        cout << "Case #" << ++ cas << ":\n" ;
        dsu.init(n) ;
        for(int i = 1 ; i <= n ; i ++)  cin >> r[i] , r[i] = __builtin_ctz(r[i]) ;
        for(int i = 1 ; i <= n ; i ++)  g[i].clear() ;
        for(int i = 1 ; i <= n ; i ++)  c[i].clear() ;
        for(int i = 0 ; i < m ; i ++)
        {
            int a , x , y ;
            cin >> a >> x >> y ;
            if(a == 1)  g[x].push_back(y) , g[y].push_back(x) ;
            else  dsu.join(x , y) ;
        }
        for(int i = 1 ; i <= n ; i ++)  c[dsu.find(i)].push_back(i) ;
        memset(vis , false , sizeof(vis)) ;
        memset(p , 0 , sizeof(p)) ;
        cnt = 0 ;
        memset(dfn , 0 , sizeof(dfn)) ;
        memset(siz , 0 , sizeof(siz)) ;
        memset(anc , 0 , sizeof(anc)) ;
        memset(L , 0x3f , sizeof(L)) ;
        memset(R , 0 , sizeof(R)) ;
        memset(l1 , 0x3f , sizeof(l1)) ;
        memset(r1 , 0 , sizeof(r1)) ;
        memset(fa , false , sizeof(fa)) ;
        memset(son , false , sizeof(son)) ;
        for(int i = 1 ; i <= n ; i ++)  
            if(!vis[i] && i == dsu.find(i))  dfs(i , 0 , i) ;
        seg.build(1 , 1 , cnt) ;
        //for(int i = )
        // cout << "!!! " << cnt << '\n' ;
        // for(int i = 1 ; i <= cnt ; i ++)
        //     cout << "??? " << seg.query(1 , 1 , cnt , i , i) << '\n' ;
        while(q --)
        {
            int a , x , y ;
            cin >> a >> x >> y ;
            y = __builtin_ctz(y) ;
            if(a == 1)  
            {
                int tmp = y - r[x] ;
                int rt = dsu.find(x) ;
                if(fa[x])  seg.add(1 , 1 , cnt , L[rt] , R[rt] , -tmp) ;
                if(son[x])  seg.add(1 , 1 , cnt , l1[x] , r1[x] , tmp) ;
                r[x] = y ;
                // cout << "!!! " << cnt << '\n' ;
                // for(int i = 1 ; i <= cnt ; i ++)
                //     cout << "??? " << seg.query(1 , 1 , cnt , i , i) << '\n' ;
            }
            else
            {
                int now = seg.query(1 , 1 , cnt , dfn[dsu.find(x)] , dfn[dsu.find(x)]) ;
                int f = y - now ;
                int rt = anc[dsu.find(x)] ;
                int ans = f + seg.query(1 , 1 , cnt , L[rt] , R[rt]) ;
                cout << fixed << setprecision(3) << ans * log(2) << '\n' ;
                //cout << ans << '\n' ;
            }
        }
    }
    return 0 ;
}

 

Problem H. Hints of sd0061

nth\_element函数线性求区间第k大。

#include<bits/stdc++.h>
using namespace std ;
const int maxn = 1e7 + 10 ;
int n , m ;
unsigned a[maxn] ;
unsigned ans[105] ;
struct node
{
    int id , x ;
    bool operator < (const node &s) const
    {
        return x < s.x ;
    }
} b[105] ;
unsigned A , B , C ;
unsigned x , y , z ;
unsigned rng61() 
{
    unsigned t ;
    x = x ^ (x << 16) ;
    x = x ^ (x >> 5) ;
    x = x ^ (x << 1) ;
    t = x ;
    x = y ;
    y = z ;
    z = ( t ^ x ) ^ y ;
    return z ;
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n , m ;
    int cas = 0 ;
    while(cin >> n >> m >> A >> B >> C)
    {
        cout << "Case #" << ++ cas << ": " ;
        x = A , y = B , z = C ;
        for(int i = 1 ; i <= n ; i ++)  a[i] = rng61() ;
        for(int i = 1 ; i <= m ; i ++)  cin >> b[i].x , b[i].id = i , b[i].x ++ ;
        sort(b + 1 , b + m + 1) ;
        for(int i = m ; i >= 1 ; i --)
        {
            if(i + 1 <= m && b[i].x == b[i + 1].x)  ans[b[i].id] = ans[b[i + 1].id] ;
            else
            {
                if(i == m)  nth_element(a + 1 , a + b[i].x , a + n + 1) ;
                else  nth_element(a + 1 , a + b[i].x , a + b[i + 1].x + 1) ;
                ans[b[i].id] = a[b[i].x] ;
            }
        }
        for(int i = 1 ; i <= m ; i ++)  cout << ans[i] << " \n"[i == m] ;
    }
    return 0 ;
}

 

Problem I. I Curse Myself

有点神的题。

因为是个仙人掌，所以可以去掉的非树边都在环上，相当于是每个环上去掉一条边。

因此题目转化为若干个序列，每个序列选择一个数，对这些数求和，询问第k大的和。

本质是多个序列的合并问题，如果直接用大小为k的set维护合并过程的话，复杂度是O(M*k*log(k))，其中M是若干个序列元素个数和。

设第i个序列的元素个数是m_i，考虑用大小为m_i的堆维护，这样复杂度是O(M*k)。

复杂度证明可以通过求导推出来。具体维护过程看代码的merge函数。

调了半天，还好一发过了。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n , m ;
    int cas = 0 ;
    while(cin >> n >> m)
    {
        cout << "Case #" << ++ cas << ": " ;
        vector<vector<pair<int , unsigned>>> g(n + 1) ;
        unsigned ans = 0 ;
        unsigned sum = 0 ;
        for(int i = 1 ; i <= m ; i ++)
        {
            int u , v , w ;
            cin >> u >> v >> w ;
            g[u].push_back({v , w}) ;
            g[v].push_back({u , w}) ;
            sum += w ;
        }
        unsigned k ;
        cin >> k ;
        vector<pair<int , unsigned>> pre(n + 1) ;
        vector<bool> vis(n + 1 , false) ;
        vector<unsigned> res ;
        vector<unsigned> val ;
        vector<unsigned> tmp ;
        vector<unsigned> c(m + 1) ;
        vector<unsigned> dfn(n + 1 , 0) ;
        int cur = 0 ;
        res.push_back(0) ;
        function<void()> merge = [&]()
        {
            priority_queue<pair<unsigned , int>> q ;
            int m = val.size() ;
            sort(val.begin() , val.end()) ;
            reverse(val.begin() , val.end()) ;
            for(int i = 0 ; i < m ; i ++)
            {
                c[i] = 0 ;
                q.push({val[i] + res[0] , i}) ;
            }
            tmp.clear() ;
            while(!q.empty() && tmp.size() < k)
            {
                auto now = q.top() ;
                q.pop() ;
                tmp.push_back(now.first) ;
                c[now.second] ++ ;
                if(c[now.second] < res.size())  
                    q.push({val[now.second] + res[c[now.second]] , now.second}) ;
            }
            swap(tmp , res) ;
        } ;
        function<void(int , int)> path = [&](int u , int anc)
        {
            if(u == anc)  return ;
            path(pre[u].first , anc) ;
            val.push_back(pre[u].second) ;
        } ;
        function<void(int , int)> dfs = [&](int fa , int u)
        {
            vis[u] = true ;
            dfn[u] = ++ cur ;
            for(auto x : g[u])
            {
                int v = x.first ;
                unsigned w = x.second ;
                if(v == fa)  continue ;
                if(vis[v] && dfn[v] > dfn[u])  continue ;
                if(vis[v] && dfn[v] < dfn[u])
                {
                    val.clear() ;
                    val.push_back(w) ;
                    path(u , v) ;
                    merge() ;
                    continue ;
                }
                pre[v] = {u , w} ;
                dfs(u , v) ;
            }
        } ;
        dfs(1 , 1) ;
        for(unsigned i = 0 ; i < res.size() ; i ++)  ans += (i + 1) * (sum - res[i]) ;
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

Problem J. Journey with Knapsack

留坑。

 

Problem K. KazaQ’s Socks

手动模拟发现循环节即可。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n ;
    long long k ;
    int cas = 0 ;
    while(cin >> n >> k)
    {
        cout << "Case #" << ++ cas << ": " ;
        if(n == 2)
        {
            if(k % 2 == 1)  cout << "1\n" ;
            else  cout << "2\n" ;
        }
        else
        {
            if(k <= n)  cout << k << '\n' ;
            else
            {
                k -= n ;
                k %= 2 * (n - 1) ;
                if(k == 0)  cout << n << '\n' ;
                else if(k <= n - 1)  cout << k << '\n' ;
                else  cout << k - (n - 1) << '\n' ;
            }
        }
    }
    return 0 ;
}

 

Problem L. Limited Permutation

分治裸题。

对于以p_{id}为最小值的[l,r]这段区间，f(l,r)=C(r-l,id-l)*f(l,id-1)*f(id+1,r)。f(l,r)是这段区间的贡献。

注意判断无解即可。

#include<bits/stdc++.h>
using namespace std ;
const int mod = 1e9 + 7 ;
const int maxn = 1e6 + 10 ;
typedef long long ll ;
ll inv1[maxn] ;  //乘法逆元
void init1(int up)
{
   inv1[1] = 1 ;
   for(int i = 2 ; i <= up ; i ++)
     inv1[i] = (ll)(mod - mod / i) * inv1[int(mod % (ll)i)] % mod ;
}
ll fac[maxn] ;
ll inv[maxn] ; //阶乘逆元
void init(int up) 
{
   fac[0] = fac[1] = inv[0] = inv[1] = 1 ;
   for(int i = 2 ; i <= up ; i ++)
   {
     fac[i] = fac[i - 1] * i % mod ;
     inv[i] = -inv[mod % i] * (mod / i) % mod ;
     while(inv[i] < 0) inv[i] += mod ;
   }
   for(int i = 2 ; i <= up ; i ++)  
     inv[i] = inv[i] * inv[i - 1] % mod ;
}
ll C(int n , int m)
{
    return fac[n] * inv[m] % mod * inv[n - m] % mod ;
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n ;
    int cas = 0 ;
    init(1000000) ;
    while(cin >> n)
    {
        cout << "Case #" << ++ cas << ": " ;
        vector<int> l(n + 1) ;
        vector<int> r(n + 1) ;
        for(int i = 1 ; i <= n ; i ++)  cin >> l[i] ;
        for(int i = 1 ; i <= n ; i ++)  cin >> r[i] ;
        vector<vector<pair<int , int>>> pos(n + 1) ;
        vector<int> cur(n + 1 , 0) ;
        for(int i = 1 ; i <= n ; i ++)  pos[l[i]].push_back({r[i] , i}) ;
        for(int i = 1 ; i <= n ; i ++)  
            sort(pos[i].begin() , pos[i].end()) , reverse(pos[i].begin() , pos[i].end()) ;
        function<long long(int , int)> solve = [&](int l , int r)
        {
            if(l > r)  return 1ll ;
            if(cur[l] == pos[l].size())  return 0ll ;
            int nxt = pos[l][cur[l]].first ;
            if(nxt != r)  return 0ll ;
            int id = pos[l][cur[l]].second ;
            cur[l] ++ ;
            return C(r - l , id - l) * solve(l , id - 1) % mod * solve(id + 1 , r) % mod ;
        } ;
        cout << solve(1 , n) << '\n' ;
    }
    return 0 ;
}

 

敲代码的欧文
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2017 Chinese Multi-University Training, BeihangU Contest 北大 多校 gym 102253
deja vu
07-25 404
2017 Chinese Multi-University Training, BeihangU Contest 北大 多校 题解 写的比较简略，简单的就不写了 gym 102253
2019 Multi-University Training Contest 4(2019hdu多校第六场数据与标程）rar
08-11
《2019 Multi-University Training Contest 4：探索ACM竞赛的魅力与技术深度》 在编程竞赛的世界里，HDU（Hangzhou Dianzi University）举办的Multi-University Training Contest一直备受关注，尤其是2019年的第六...
【2017 Chinese Multi-University Training, BeihangU Contest】A. Add More Zero
aoping9329的博客
07-03 188
题目描述 给定 $m$，求最大的 $k$，使得 $0 \le 10^k \le 2^m-1$，其中 $1 \le m \le 10^5$ 社论 显然 $10^k < 2^m \Rightarrow k < m \lg 2$，右边是个无理数，直接下取整即可 转载于:https://www.cnblogs.com/KingSann/articles/11126161.ht...
【2017 Chinese Multi-University Training, BeihangU Contest】K. KazaQ's Socks
aoping9329的博客
07-03 138
题目描述 社论 不难发现，最后的序列是这样的：$1 \sim n, (1 \sim n-2,n-1),(1 \sim n-2,n),(1\sim n-2,n-1), (1 \sim n-2,n),\cdots$ 判一下就好了 转载于:https://www.cnblogs.com/KingSann/articles/11126282.html...
快乐组队赛XD（2017 Chinese Multi-University Training, BeihangU Contest）
hello world
08-30 274
第三步，定数字的值，虽然前面求了贡献度，按理来说可以直接贡献度排序，但现实总是悲惨的，贡献度数字太大被取模了无法比较，这时候我们令每个字母都为1，用数组通过十进制的形式存储式子，即第i个字母的贡献度为26^j*a[i][j]，并且处理进位。K. KazaQ's Socks：大致题意：有个b不爱洗袜子，他有n双袜子，编号1-n，他每天白天挑出干净袜子中id最小的穿，晚上脱掉了，如果脏袜子到了n-1双袜子，就丢去洗，第二天晚上才会干。如果b的循环长度为a的循环长度的因数，就可以带入，种类数为b的循环长度。...
「2017 Multi-University Training Contest 7」2017多校训练7
dingguayi7025的博客
08-18 104
1002 Build a tree（递归） 题目链接 HDU6121 Build a tree 有一棵n个点的有根树，标号为0到n-1，i号点的父亲是\(\lfloor\frac{i-1}{k}\rfloor\)号点，求所有子树大小的异或和。\(1\leq n,k\leq10^{18}\)。 找出n所在的链，然后从根开始递归处理。 k=1的时候特判，1异或到n，每4个异或起来为0。 #i...
有2019 Multi-University Training Contest 9，hdu多校第9场的题解.zip
08-19
《2019 Multi-University Training Contest 9 HDU多校第9场题解解析》 在编程竞赛的世界中，ACM（国际大学生程序设计竞赛）是一项备受瞩目的活动，它旨在培养学生的算法设计、问题解决和编程能力。2019年，多所大学...
2019 Multi-University Training Contest 10数据标程.rar
08-22
标题中的“2019 Multi-University Training Contest 10数据标程.rar”指的是2019年举办的多所大学联合编程训练比赛的第十场竞赛的数据集和参考解程。这个压缩包通常包含了该比赛的所有题目、输入输出样例、评测标准...
有2019 Multi-University Training Contest 8数据标程.rar
08-19
有2019 Multi-University Training Contest 8，hdu多校第8场的题解，数据标程，有需要的可以下载哦
2019 Multi-University Training Contest 7数据标程.rar
08-19
《2019 Multi-University Training Contest 7数据标程》是针对 ACM（国际大学生程序设计竞赛）的一份宝贵资源，特别关注了 HDU（杭州电子科技大学）组织的多校第七场比赛。这份压缩包文件包含了该比赛的题解和数据标...
2017 Multi-University Training Contest 第一场
qq_24664053的博客
07-27 238
题解在：http://bestcoder.hdu.edu.cn/blog/2017-multi-university-training-contest-8-solutions-by-%E5%8C%97%E4%BA%AC%E8%88%AA%E7%A9%BA%E8%88%AA%E5%A4%A9%E5%A4%A7%E5%AD%A6/#comment-42四题200多名吧 反正就只能切水题1001 求2
2017 Multi-University Training Contest - Team 3（补题系列）
AcLings的博客
08-02 294
2017 Multi-University Training Contest - Team 3 RXD's date Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 524288/524288 K (Java/Others) Total Submission(s): 208    Accepted Submission(s):
2017 Multi-University Training Contest - Team 3 & hdu6058、Kanade's sum
愚者
08-08 207
题目： Problem Description Give you an array A[1..n]of length n. Let f(l,r,k) be the k-th largest element of A[l..r]. Specially , f(l,r,k)=0 if r−l+1k. Give you k , you need to ca
Java中的Lambda
qq_25775675的博客
07-07 3072
大家应该都知道面向对象的特性（抽象、封装、继承、多态）。其实在 出现之前，我们关注的往往是某一类对象应该具有什么样的属性，当然这也是面向对象的核心–对数据进行抽象。但是出现以后，这一点开始出现变化，在某种场景下，更加关注某一类共有的行为（这与之前的接口有些类似），这也就是提出函数式编程的目的。面向对象编程到面向行为编程的变化我们知道，对于一个变量，我们可以赋给其一个**“值”**。如果你想把**“一块代码”**赋给一个变量，应该怎么做呢？比如，我想把右边那块代码，赋给一个叫做的变量：在之前，这个是做不到的
2018 Chinese Multi-University Training, Nanjing U Contest(多校第八场)
jziwjxjd的博客
10-09 339
E - Magic Square 没什么好说的,模拟转转转就好了,自认为我写的还是比较简便的. #include <bits/stdc++.h> using namespace std; const int maxn = 3e5+10; int t,n; char a[101][101]; void rotate(int x,int y,int num) { for(int i=1;i<=num;i++) { char q = a[x][y], w = a[x][y+1], e =
DFS问题
太菜了
03-07 307
7-1 整数分解为若干项之和 (20分) 输入格式： 每个输入包含一个测试用例，即正整数N (0<N≤30)。 输出格式： 按递增顺序输出N的所有整数分解式子。递增顺序是指：对于两个分解序列N ​1 ​​ ={n ​1 ​​ ,n ​2 ​​ ,⋯}和N ​2 ​​ ={m ​1 ​​ ,m ​2 ​​ ,⋯}，若存在i使得n ​1 ​​ =m ​1 ​​ ,⋯,n ​i ​​ =m ​i ...
语法记录()
jestingi的博客
04-12 975
set: 禁用：不可直接修改元素（常指针） 二分查找 : set s; auto t = s.lower_bound(x); //返回第一个大于等于x的指针 指针移动访问前后元素: auto t = s.begin(); t ++; cout << *t; basic_string： 两边加元素： basic_string s; s = s + (int)x + s ......
2018 Multi-University Training Contest 2
三水的鱼塘♂
07-26 236
hdu 6312 Game   可以自己从1-8试一下，发现alice必赢。 输出yes即可   #include&lt;bits/stdc++.h&gt; using namespace std; int main(){ int n; while(cin&gt;&gt;n) { cout&lt;&lt;"Yes"&lt;&lt;endl; ...
动态规划(dynamic programming)学习笔记（上）
xiaqi4145
08-12 183
一、概述 key point： 1、确定原问题与子问题 2、阶段的状态（包含边界状态（或者说是边界条件）） 3、状态转移方程(难点也是最重要的一点) 二、例题1 keypoint: 如果用递归(本质是压栈和出栈的过程)，提交的时候编译器会报超时，（因为n很大的时候，有很多重复计算）（拆成二叉树理解，比如climbStairs(5）拆成climbStairs(4)+cl...
2017-CCPC-FINAL
最新发布
10-04
引用:2017 CCPC Final Contest Onsite Round, Sunday, December 3rd, 2017 Problem A. Dogs and Cages Jerry likes dogs. He has N dogs numbered 0, 1, . . . , N − 1. He also has N cages numbered 0, 1, . . . , N ...。 引用:单纯型算法，之前学了一下线性规划，然而算法还不会，有一点思路。 先二分答案p，判断是否可行。枚举所有选人的 2N 种情况，对其中可以选择的情况，选中的人 p ，没有选中的人 (p−1) 。 那么最后要使得所有的人都 >=0 ，且至少选择一种开奖情况。 直接单纯形判断解是否存在即可。时间复杂度 O(k∗Simplex) 。 G：Alice’s Stamps 。 引用:显然是个dp，令f[i][j]表示前i套选了j套的最优。先按l从小到大，l一样按r从小到大排序，每次选取最远的一个r进行转移。 H：Equidistance 。 2017-CCPC-FINAL是指2017年CCPC全国大学生程序设计竞赛的决赛。决赛于2017年12月3日举行，涉及多个问题，包括问题A：狗和笼子，问题G：Alice的邮票和问题H：等距离等。在问题A中，Jerry有N只狗和N个笼子，他需要将每只狗放入一个笼子。在问题G中，涉及到单纯型算法和线性规划。在问题H中，涉及到动态规划的思想。这些问题都是在程序设计竞赛中解决的典型例子。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值