2018-2019 ACM-ICPC, Asia Nakhon Pathom Regional Contest 部分题解

于 2021-02-16 19:50:04 发布
阅读量626 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Irving0323/article/details/113827582
版权

比赛链接

Problem A Flying Squirrel

设[l,r]区间最大值的下标是id，那么区间被划分为了左区间[l,id-1]和右区间[id+1,r]。左右区间不可达，相当于是划分。

如果每个区间内只有一个最大值，那么这其实是一个类似于线段树的东西。

但是因为可能有多个相同的最大值，所以其实是个分层图。不严格地说，每个节点既可以有多个父亲，又可以有多个儿子。

每个区间内相同的最大值深度相同，进行划分即可。

y=0时，答案是x子树内部的深度最大值减去x的深度。

y\neq 0时，如果x,y之间没有大于等于h[x]的柱子，也就是x可以到达y。那么答案就是两者深度差的绝对值。

#include<bits/stdc++.h>
using namespace std ;
const int maxn = 1e5 + 10 ;
int n , q ;
int a[maxn] ;  //区间最大值对应的下标
int st[maxn][25] ;
void init() 
{
   for(int i = 1 ; i <= n ; i ++) st[i][0] = i ; 
   for(int j = 1 ; j <= 20 ; j ++)
   for(int i = 1 ; i + (1 << j) - 1 <= n ; i ++)
     if(a[st[i][j - 1]] >= a[st[i + (1 << (j - 1))][j - 1]])
       st[i][j] = st[i][j - 1] ;
     else  st[i][j] = st[i + (1 << (j - 1))][j - 1] ; 
}
int query(int l,int r)
{ 
   int len = log2(r - l + 1) ;
   if(a[st[l][len]] >= a[st[r - (1 << len) + 1][len]])  return st[l][len] ;
   else  return st[r - (1 << len) + 1][len] ;
}
int ans[maxn] ;
int dep[maxn] ;
vector<int> p ;
void dfs(int l , int r , int val , int d)
{
    if(l > r)  return ;
    int id = query(l , r) ;
    if(a[id] != val)  return ;
    p.push_back(id) ;
    dep[id] = d ;
    dfs(l , id - 1 , val , d) ;
    dfs(id + 1 , r , val , d) ;
}
int solve(int l , int r , int d)
{
    int res = d ;
    int id = query(l , r) ;
    p.clear() ;
    dfs(l , r , a[id] , d) ;
    vector<int> pos = p ;
    int siz = pos.size() ;
    if(dep[l] == 0)
    {
        int t = pos[0] ;
        int tmp = solve(l , t - 1 , d + 1) ;
        res = max(res , tmp) ;
        ans[t] = max(ans[t] , tmp - d) ;
    }
    if(dep[r] == 0)
    {
        int t = pos[siz - 1] ;
        int tmp = solve(t + 1 , r , d + 1) ;
        res = max(res , tmp) ;
        ans[t] = max(ans[t] , tmp - d) ;
    }
    for(int i = 0 ; i + 1 < siz ; i ++)
    {
        int now = pos[i] ;
        int nxt = pos[i + 1] ;
        if(now + 1 == nxt)  continue ;
        int tmp = solve(now + 1 , nxt - 1 , d + 1) ;
        res = max(res , tmp) ;
        ans[now] = max(ans[now] , tmp - d) ;
        ans[nxt] = max(ans[nxt] , tmp - d) ;
    }
    return res ;
}
void init2()
{
    solve(1 , n , 1) ;
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    cin >> n >> q ;
    for(int i = 1 ; i <= n ; i ++)  cin >> a[i] ;
    init() ;
    init2() ;
    //for(int i = 1 ; i <= n ; i ++)  cout << i << ' ' << dep[i] << ' ' << ans[i] << '\n' ;
    while(q --)
    {
        int l , r ;
        cin >> l >> r ;
        if(r == 0)  cout << ans[l] << '\n' ;
        else
        {
            if(dep[l] > dep[r])  swap(l , r) ;
            if(dep[l] == dep[r])  cout << "0\n" ;
            else if(l < r)
            {
                int id = query(l + 1 , r) ;
                if(dep[id] <= dep[l])  cout << "0\n" ;
                else  cout << dep[r] - dep[l] << '\n' ;
            }
            else
            {
                int id = query(r , l - 1) ;
                if(dep[id] <= dep[l])  cout << "0\n" ;
                else  cout << dep[r] - dep[l] << '\n' ;
            }
        }
    }
    return 0 ;
}

 

Problem B Grid Coloring

留坑。

 

Problem C Evolution Game

按照horns的大小升序排列。

j<i且两者的eyes数量不超过w。dp[i]=max(dp[i],dp[j]+1)。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int n , w ;
    cin >> n >> w ;
    vector<pair<int , int>> v(n + 1) ;
    for(int i = 1 ; i <= n ; i ++)
    {
        int h ;
        cin >> h ;
        v[i] = {h , i} ;
    }
    sort(v.begin() + 1 , v.end()) ;
    vector<int> dp(n + 1 , 0) ;
    for(int i = 2 ; i <= n ; i ++)
        for(int j = 1 ; j < i ; j ++)
            if(abs(v[j].second - v[i].second) <= w && v[j].first < v[i].first)
                dp[i] = max(dp[i] , dp[j] + 1) ;
    cout << *max_element(dp.begin() + 1 , dp.end()) ;
    return 0 ;
}

 

Problem D Bus Stop

从左往右扫，扫到x时，如果[x-10,x+10]的范围内没有stops，那么在x+10的位置安装一个stops。

#include<bits/stdc++.h>
using namespace std ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    while(T --)
    {
        int n ;
        cin >> n ;
        vector<int> a(n + 1) ;
        for(int i = 1 ; i <= n ; i ++)  cin >> a[i] ;
        int lst = -100000 ;
        int ans = 0 ;
        for(int i = 1 ; i <= n ; i ++)
        {
            if(abs(a[i] - lst) <= 10)  continue ;
            else  lst = a[i] + 10 , ans ++ ;
        }
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

Problem E How many groups

本来写了200多行的分类讨论，虽然过了，不过很不爽。

看了别人代码发现是个简单dp，感觉失去了一个亿。

分类讨论。

#include<bits/stdc++.h>
using namespace std ;
int n ;
int a[105] ;
int l[105] ;
int r[105] ;
int c[2] = {-1 , 1} ;
int d[4] = {-1 , 1 , 0 , 0} ;
int e[4] = {0 , 0 , -1 , 1} ;
int cal1(int i)
{
    int res = 1 ;
    if(i - 1 >= 1 && abs(a[i - 1] - a[i]) <= 2)  res += ((i - 1) - l[i - 1] + 1) ;
    if(i + 1 <= n && abs(a[i + 1] - a[i]) <= 2)  res += (r[i + 1] - (i + 1) + 1) ;
    return res ;
}
int cal2(int i , int j)
{
    if(abs(a[i] - a[j]) > 2)  return 0 ;
    int res = 2 ;
    if(i - 1 >= 1 && abs(a[i - 1] - a[i]) <= 2)  res += ((i - 1) - l[i - 1] + 1) ;
    if(j + 1 <= n && abs(a[j + 1] - a[j]) <= 2)  res += (r[j + 1] - (j + 1) + 1) ;
    return res ;
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    for(int cas = 1 ; cas <= T ; cas ++)
    {
        cout << "Case " << cas << ": " ;
        cin >> n ;
        for(int i = 1 ; i <= n ; i ++)  cin >> a[i] ;
        sort(a + 1 , a + n + 1) ;
        int ans = 0 ;
        for(int i = 1 ; i <= n ; i ++)
        {
            int j = i ;
            while(j + 1 <= n && a[j + 1] - a[j] <= 2)  j ++ ;
            for(int k = i ; k <= j ; k ++)  l[k] = i , r[k] = j ;
            ans = max(ans , j - i + 1) ;
            i = j ;
        }
        for(int i = 1 ; i <= n ; i ++)  
        {
            int tmp = a[i] ;
            for(int j = 0 ; j < 2 ; j ++)
            {
                a[i] = tmp + c[j] ;
                ans = max(ans , cal1(i)) ;
            }
            a[i] = tmp ;
        }
        for(int i = 1 ; i <= n - 1 ; i ++)
        {
            int tmp1 = a[i] ;
            int tmp2 = a[i + 1] ;
            for(int j = 0 ; j < 2 ; j ++)
                for(int k = 0 ; k < 2 ; k ++)
                {
                    a[i] = tmp1 + c[j] ;
                    a[i + 1] = tmp2 + c[k] ;
                    ans = max(ans , cal2(i , i + 1)) ; 
                }
            a[i] = tmp1 ;
            a[i + 1] = tmp2 ;
        }
        //cout << ans << '\n' ;
        for(int i = 1 ; i <= n ; i ++)
        {
            int res = 1 ;
            a[i] ++ ;
            if(i + 1 <= n)
            {
                if(i - 1 >= 1 && abs(a[i] - a[i - 1]) <= 2)  res += (i - 1) - l[i - 1] + 1 ;
                ans = max(ans , res) ;
                if(abs(a[i] - a[i + 1]) <= 2)
                {
                    res += r[i + 1] - (i + 1) + 1 ;
                    ans = max(ans , res) ;
                    int nxt = r[i + 1] ;
                    //cout << nxt << '\n' ;
                    if(nxt + 1 <= n)
                    {
                        int tmp1 = a[nxt] ;
                        int tmp2 = a[nxt + 1] ;
                        for(int j = 0 ; j < 4 ; j ++)
                            {
                                a[nxt] = tmp1 + d[j] ;
                                a[nxt + 1] = tmp2 + e[j] ;
                                int tt = res ;
                                if(abs(a[nxt] - a[nxt + 1]) <= 2)
                                {
                                    if(abs(a[nxt] - a[nxt - 1]) <= 2)
                                    {
                                        tt ++ ;
                                        //cout << res << '\n' ;
                                        if(nxt + 2 <= n && abs(a[nxt + 1] - a[nxt + 2]) <= 2)
                                        {
                                            tt += r[nxt + 2] - (nxt + 2) + 1 ;
                                        }
                                        ans = max(ans , tt) ;
                                    }
                                }
                            }
                        a[nxt] = tmp1 ;
                        a[nxt + 1] = tmp2 ;
                    }
                }
            }
            a[i] -- ;
            
            res = 1 ;
            a[i] -- ;
            if(i + 1 <= n)
            {
                if(i - 1 >= 1 && abs(a[i] - a[i - 1]) <= 2)  res += (i - 1) - l[i - 1] + 1 ;
                ans = max(ans , res) ;
                if(abs(a[i] - a[i + 1]) <= 2)
                {
                    res += r[i + 1] - (i + 1) + 1 ;
                    ans = max(ans , res) ;
                    int nxt = r[i + 1] ;
                    //cout << nxt << '\n' ;
                    if(nxt + 1 <= n)
                    {
                        int tmp1 = a[nxt] ;
                        int tmp2 = a[nxt + 1] ;
                        for(int j = 0 ; j < 4 ; j ++)
                            {
                                a[nxt] = tmp1 + d[j] ;
                                a[nxt + 1] = tmp2 + e[j] ;
                                int tt = res ;
                                if(abs(a[nxt] - a[nxt + 1]) <= 2)
                                {
                                    if(abs(a[nxt] - a[nxt - 1]) <= 2)
                                    {
                                        tt ++ ;
                                        //cout << res << '\n' ;
                                        if(nxt + 2 <= n && abs(a[nxt + 1] - a[nxt + 2]) <= 2)
                                        {
                                            tt += r[nxt + 2] - (nxt + 2) + 1 ;
                                        }
                                        ans = max(ans , tt) ;
                                    }
                                }
                            }
                        a[nxt] = tmp1 ;
                        a[nxt + 1] = tmp2 ;
                    }
                }
            }
            a[i] ++ ;
        }
        //cout << ans << '\n' ;
        for(int i = 1 ; i <= n ; i ++)
        {
            a[i] -- ;
            int res = 1 ;
            if(i - 1 >= 1)
            {
                if(i + 1 <= n && abs(a[i] - a[i + 1]) <= 2)  res += r[i + 1] - (i + 1) + 1 ;
                ans = max(ans , res) ;
                if(abs(a[i] - a[i - 1]) <= 2)
                {
                    res += (i - 1) - l[i - 1] + 1 ;
                    ans = max(ans , res) ;
                    int nxt = l[i - 1] ;
                    if(nxt - 1 >= 1)
                    {
                        int tmp1 = a[nxt] ;
                        int tmp2 = a[nxt - 1] ;
                        for(int j = 0 ; j < 4 ; j ++)
                            {
                                int tt = res ;
                                a[nxt] = tmp1 + d[j] ;
                                a[nxt - 1] = tmp2 + e[j] ;
                                if(abs(a[nxt] - a[nxt - 1]) <= 2)
                                {
                                    if(abs(a[nxt] - a[nxt + 1]) <= 2)
                                    {
                                        tt ++ ;
                                        if(nxt - 2 >= 1 && abs(a[nxt - 1] - a[nxt - 2]) <= 2)
                                        {
                                            tt += (nxt - 2) - l[nxt - 2] + 1 ;
                                        }
                                        ans = max(ans , tt) ;
                                    }
                                }
                            }
                        a[nxt] = tmp1 ;
                        a[nxt - 1] = tmp2 ;
                    }
                }
            }
            a[i] ++ ;
        
            a[i] ++ ;
            res = 1 ;
            if(i - 1 >= 1)
            {
                if(i + 1 <= n && abs(a[i] - a[i + 1]) <= 2)  res += r[i + 1] - (i + 1) + 1 ;
                ans = max(ans , res) ;
                if(abs(a[i] - a[i - 1]) <= 2)
                {
                    res += (i - 1) - l[i - 1] + 1 ;
                    ans = max(ans , res) ;
                    int nxt = l[i - 1] ;
                    if(nxt - 1 >= 1)
                    {
                        int tmp1 = a[nxt] ;
                        int tmp2 = a[nxt - 1] ;
                        for(int j = 0 ; j < 4 ; j ++)
                            {
                                int tt = res ;
                                a[nxt] = tmp1 + d[j] ;
                                a[nxt - 1] = tmp2 + e[j] ;
                                if(abs(a[nxt] - a[nxt - 1]) <= 2)
                                {
                                    if(abs(a[nxt] - a[nxt + 1]) <= 2)
                                    {
                                        tt ++ ;
                                        if(nxt - 2 >= 1 && abs(a[nxt - 1] - a[nxt - 2]) <= 2)
                                        {
                                            tt += (nxt - 2) - l[nxt - 2] + 1 ;
                                        }
                                        ans = max(ans , tt) ;
                                    }
                                }
                            }
                        a[nxt] = tmp1 ;
                        a[nxt - 1] = tmp2 ;
                    }
                }
            }
            a[i] -- ;
        }
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

dp[i][j][k]表示前i个数修改了j次且第i个数是a[i]+k-1的以i为右端点的最大连续段长度。

#include<bits/stdc++.h>
using namespace std ;
int n , a[105] ;
int dp[105][3][3] ;
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    for(int cas = 1 ; cas <= T ; cas ++)
    {
        cout << "Case " << cas << ": " ;
        cin >> n ;
        for(int i = 1 ; i <= n ; i ++)  cin >> a[i] ;
        sort(a + 1 , a + n + 1) ;
        for(int i = 0 ; i <= n ; i ++)  
            for(int j = 0 ; j <= 2 ; j ++)  
                for(int k = 0 ; k <= 2 ; k ++)
                    dp[i][j][k] = -1e9 ;
        int fix = 1 ;
        for(int i = 1 ; i <= n ; i ++)
        {
            dp[i][0][fix + 0] = 1 ;
            dp[i][1][fix - 1] = 1 ;
            dp[i][1][fix + 1] = 1 ;
        }
        for(int i = 1 ; i < n ; i ++)  
            for(int j = 0 ; j <= 2 ; j ++)
                for(int k = 0 ; k <= 2 ; k ++)
                    for(int p = j ; p <= 2 ; p ++)
                        for(int t = 0 ; t <= 2 ; t ++)
                        {
                            if(dp[i][j][k] < 0)  continue ;
                            int now = a[i] + k - fix ;
                            int nxt = a[i + 1] + t - fix ;
                            if(abs(now - nxt) <= 2 && (j + abs(t - fix)) == p)
                            {
                                dp[i + 1][p][t] = max(dp[i + 1][p][t] , dp[i][j][k] + 1) ;
                            }
                        }
        int ans = 0 ;
        for(int i = 1 ; i <= n ; i ++)
            for(int j = 0 ; j <= 2 ; j ++)
                for(int k = 0 ; k <= 2 ; k ++)
                    ans = max(ans , dp[i][j][k]) ;
        cout << ans << '\n' ;
    }
    return 0 ;
}

 

Problem F Lucky Pascal Triangle

求满足n \leq N,m \leq N,7 \mid \binom{n}{m}的n和m的对数

库默尔定理：\binom{n+m}{m}中p的幂次为n+m在p进制下进位次数，p为质数

题目可以转化为求n-m和m在7进制下产生了进位的对数

数位dp：f[i][j][lim][d]表示从高到低考虑到第i位，已经产生了j个进位，是否有大小限制，是否强制下一位产生进位的方案数

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int p = 7, mod = 1e9 + 7;
int kas;
ll n;
int a[25], len;
int f[25][2][2][2];
inline void Add(int &x, int y) { x += y; if(x>=mod) x -= mod; }
void change(ll n)
{
    len = 0;
    while(n)
    {
        a[len++] = n%p;
        n /= p; 
    }
}
int count(int x)
{
    if(x<p) return (1ll*(x+1)*(x+2)>>1)%mod;
    x = 2*p - 2 - x;
    return (1ll*p*p-(1ll*(x)*(x+1)>>1))%mod;
}
int cal(int l, int r) { return (count(r)-count(l-1)+mod)%mod; }
void solve()
{
    scanf("%lld", &n);
    change(n);
    for(int i=0; i<=len; i++) memset(f[i], 0, sizeof(f[i]));
    f[len][0][1][0] = 1;
    for(int i=len; i; i--)
        for(int j=0; j<2; j++)
            for(int lim=0; lim<2; lim++)
                for(int d=0; d<2; d++) if(f[i][j][lim][d])
                    for(int nxtd=0; nxtd<2; nxtd++)
                    {
                        int l = d*p - nxtd, r = (lim ? a[i-1] : p-1) + l;
                        if(lim) Add(f[i-1][j|nxtd][0][nxtd], 1ll*f[i][j][1][d]*cal(l, r-1)%mod), Add(f[i-1][j|nxtd][1][nxtd], 1ll*f[i][j][1][d]*cal(r, r)%mod);
                        else Add(f[i-1][j|nxtd][0][nxtd], 1ll*f[i][j][0][d]*cal(l, r)%mod);
                    }
    int ans = (f[0][1][0][0] + f[0][1][1][0])%mod;
    printf("Case %d: %d\n", ++kas, ans);
}
int main()
{
    int _; scanf("%d", &_);
    while(_--) solve();
    return 0;
}

 

Problem G Communication

题面的英语写的过于上等。没说message是可传递的，然后写了个并查集果然WA了。

反应过来如果可以传递就是一个SCC，贴个板子就过了。

#include<bits/stdc++.h>
using namespace std ;
const int maxn = 200 + 10 ;
const int maxm = 10000 + 10 ;
int n ;
struct Link
{
    int num , head[maxn] ;
    struct Edge
    {
        int v , next ;
    } edge[maxm << 1] ;
    void init()
    {
        num = 0 ;
        memset(head , -1 , sizeof(head)) ;
    }
    void add_edge(int u , int v)
    {
        edge[num].v = v ;
        edge[num].next = head[u] ;
        head[u] = num ++ ;  
    } 
} link ;
struct Tarjan
{
    int cnt , scc_num , lay ;
    int low[maxn] , dfn[maxn] , belong[maxn] ; 
    int st[maxn] , s[maxn] ;
    bool vis[maxn] ;
    void init()
    {
        cnt = scc_num = lay = 0 ;
        memset(vis , 0 , sizeof(vis)) ;
        memset(low , 0 , sizeof(low)) ;
        memset(dfn , 0 , sizeof(dfn)) ;
    }
    void dfs(int k)
    {
        vis[k] = 1 ;
        low[k] = dfn[k] = ++ lay ;
        st[++ cnt] = k ;
        for(int i = link.head[k] ; i != -1 ; i = link.edge[i].next)
        {
            int v = link.edge[i].v ;
            if(dfn[v] == 0)
            {
                dfs(v) ;
                low[k] = min(low[k] , low[v]) ;
            }
            else if(vis[v])
            low[k] = min(low[k] , dfn[v]) ;
        }
        if(dfn[k] == low[k])
        {
            ++ scc_num ;
            do
            {
                belong[st[cnt]] = scc_num ;
                vis[st[cnt]] = 0 ;
                cnt -- ;
            } while(st[cnt + 1] != k) ;
        }
    }
    void cal()
    {
        for(int i = 1 ; i <= n ; i ++)
        if(dfn[i] == 0)  dfs(i) ;
    }
} tarjan ; 
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    int T ;
    cin >> T ;
    while(T --)
    {
        cin >> n ;
        link.init() ;
        tarjan.init() ;
        int e ;
        cin >> e ;
        for(int i = 1 ; i <= e ; i ++)
        {
            int u , v ;
            cin >> u >> v ;
            u ++ ;
            v ++ ;
            link.add_edge(u , v) ;
        }
        tarjan.cal() ;
        cout << tarjan.scc_num << '\n' ;
    }
    return 0 ;
}

 

Problem H As rich as Crassus

留坑。

 

Problem I Bowabowaukulipukuli

留坑。

 

Problem J Floating-Point Hazard

需要看出来这是求导定义式的分子。

f(x)=x^{\frac{1}{3}}，求导后得到f^{'}(x)。

答案是\sum f^{'}(i)*(10^{-15})。

#include<bits/stdc++.h>
using namespace std ;
#define ld long double
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;
    while(1)
    {
        int l , r ;
        scanf("%d%d" , &l , &r) ;
        if(l == 0 && r == 0)  break ;
        ld ans = 0 ;
        for(int i = l ; i <= r ; i ++)  ans += pow(i , -2.0 / 3.0) ;
        ans /= 3.0 ;
        int res = 15 ;
        while(ans >= 10.0)  ans /= 10 , res -- ;
        while(ans < 1.0)  ans *= 10 , res ++ ;
        printf("%.5LfE-" , ans) ;
        printf("%03d\n" , res) ;
    }
    return 0 ;
}

 

Problem K The Stream of Corning 2

裸的第k大。

#include <bits/stdc++.h>
#define all(x) begin(x), end(x)
using namespace std;
const int N = 1e5 + 5;
const int MAXSIZE = 1 << 20;
char buf[MAXSIZE], *p1, *p2;
inline char gc() { return (p1==p2&&(p2=(p1=buf)+fread(buf,1,MAXSIZE,stdin),p1==p2) ? EOF : *p1++); }
inline void read(int& t)
{
    t = 0; char c = gc();
    while(c>'9'||c<'0') c = gc();
    while(c>='0'&&c<='9') t = t*10 + c - 48, c = gc();
}
bool qry[N];
int kas;
int n, ans[N];
struct Event
{
    int t, v, op;
    bool operator < (const Event& oth) { return t==oth.t ? op<oth.op : t<oth.t; }
}e[N<<1];
struct seg
{
    int l, r, cnt;
}t[N<<2];
void up(int p) { t[p].cnt = t[p<<1].cnt + t[p<<1|1].cnt; }
void build(int p, int l, int r)
{
    t[p].l = l, t[p].r = r, t[p].cnt = 0;
    if(l==r) return;
    int mid = (l+r)>>1;
    build(p<<1, l, mid); build(p<<1|1, mid+1, r);
}
void upd(int p, int x, int v)
{
    int l = t[p].l, r = t[p].r;
    if(l==r) 
    {
        t[p].cnt += v;
        return;
    }
    int mid = (l+r) >> 1;
    if(x<=mid) upd(p<<1, x, v);
    else upd(p<<1|1, x, v);
    up(p);
}
int ask(int p, int k) 
{
    int l = t[p].l, r = t[p].r;
    if(l==r) return t[p].cnt>=k ? l : -1;
    if(t[p<<1].cnt>=k) return ask(p<<1, k);
    else return ask(p<<1|1, k-t[p<<1].cnt);
}
void solve()
{
    read(n);
    int m = 0;
    vector<int> lsh;
    auto getid = [&](int x) { return lower_bound(all(lsh), x) - begin(lsh) + 1; };
    for(int i=1; i<=n; i++)
    {
        qry[i] = 0;
        int op; read(op);
        if(op==1)
        {
            int l, v, r; read(l), read(v), read(r);
            e[++m] = {l, v, 1};
            e[++m] = {r+1, v, -1};
            lsh.push_back(v);
        }
        else
        {
            qry[i] = 1;
            int t, k; read(t), read(k);
            e[++m] = {t, k, i+1};
        }
    }
    sort(all(lsh));
    lsh.resize(unique(all(lsh)) - begin(lsh));
    build(1, 1, (int)lsh.size());
    sort(e+1, e+m+1);
    for(int i=1; i<=m; i++)
    {
        if(e[i].op<=1) upd(1, getid(e[i].v), e[i].op);
        else ans[e[i].op-1] = ask(1, e[i].v);
    }
    printf("Case %d:\n", ++kas);
    for(int i=1; i<=n; i++) 
        if(qry[i]) 
        {
            if(ans[i]==-1) puts("-1");
            else printf("%d\n", lsh[ans[i]-1]);
        }
}
int main()
{
    int _; read(_);
    while(_--) solve();
    return 0;
}

 

Problem L Largest Allowed Area

看作二维平面上的点，在斜率是-1的直线上进行双指针扫描，以L作为左上角的点，R作为右下角的点。前缀和预处理后可以O(1)判断正方形内1的个数。

不过这题卡常，需要快读。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5, inf = 1e9;
int n, m;
int a[N][N], r[N][N], s[N][N];
int qry(int x1, int y1, int x2, int y2) { return s[x2][y2]+s[x1-1][y1-1]-s[x2][y1-1]-s[x1-1][y2]; }
inline void read(int& t)
{
    t = 0; 
    char c = getchar();
    while(c>'9'||c<'0') c = getchar();
    while(c>='0'&&c<='9') t = t*10 + c - 48, c = getchar();
}
void solve()
{
    read(n), read(m);
    for(int i=1; i<=n; i++)
        for(int j=1; j<=m; j++) read(a[i][j]), s[i][j] = s[i][j-1]+s[i-1][j]-s[i-1][j-1]+a[i][j];
    for(int i=0; i<=n; i++)
        for(int j=0; j<=m; j++) r[i][j] = i;
    int ans = 0;
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            int rgt = r[i-1][j-1];
            while(rgt+1<=i && qry(rgt+1, rgt+1+j-i, i, j)>1) rgt++;
            ans = max(ans, i-rgt);
            r[i][j] = rgt;
        }
    }
    printf("%d\n", ans);
}
int main()
{
    int _; read(_);
    while(_--) solve(); 
    return 0;
}

 

敲代码的欧文
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2018-2019 ACM-ICPC, Asia Nanjing Regional Contest
bibibibi的博客
12-23 796
施工中（8/13） 题目链接：http://codeforces.com/gym/101981   A.Adrien and Austin   队友写的，没看题   代码： #include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN=1e6+5; int n,k; void solve() { int...
2015-2016 ACM-ICPC Northeastern European Regional Contest 标程
08-23
【标题】"2015-2016 ACM-ICPC Northeastern European Regional Contest 标程" 提供的是一个编程竞赛的参考资料，这是一场由ACM（Association for Computing Machinery）主办的国际大学生程序设计竞赛（International...
【GYM102091】2018-2019 ACM-ICPC, Asia Nakhon Pathom Regional Contest
henucm的博客
04-18 755
传送门 题目大意：给一些有向边，如果两个点可以互达，那么这两个点属于同一组，求你给有向图分组。 题解：Floyed+并查集。 #include<bits/stdc++.h> using namespace std; int per[350]; int find(int x) { if(x==per[x]) return x; return per[x]=find(per[...
2018-2019 ACM-ICPC, Asia Nakhon Pathom Regional Contest
bjfu170203101的博客
03-09 727
L:Largest Allowed Area 我是记录前缀方形数组sum[i][j]表示前i行和前j列这个方形内数字总和。 然后就可以用这个表示出第i，j点，边长。n的方形中间的数的和。 如果小于1等于就满足。 这里有点奇怪。。。用一般的输入挂982ms（就是我注释的）， 用高级挂。。。171ms。。。卧槽。。？？？ 好像有单调队列的做法，等会看了补上。 #include&lt;b...
2018-2019 ACM-ICPC, Asia Nakhon Pathom Regional Contest 寒假自训第二场
ccsu_cat
01-30 1994
跟着付队一起打的第二场gym，差点就被付队爆0了，还好趁他不注意切了两个水题（付队tql） C.Evolution Game 题意：有n个不同版本的野兽，定义属性：第 i 个野兽有 i 个眼睛和 h[i] 个角，你可以任意从中选择一个野兽进行进化，每次进化角数量必须增加，而且进化后假设有a 个眼睛 b个角，假设h[i]=b，那么abs(a-i)&lt;=w，否则不能进化，求最多的进化次数。 ...
2018-2019 ACM-ICPC, Asia Nakhon Pathom Regional Contest E How Many Groups
逝者如斯夫，不舍昼夜
09-03 264
How Many Groups You are given an array of n integers. Define a binary relation ~ on the elements of this array so that x ~ y if and only if |x – y| is less than or equal to 2. Let ~* be the transitive...
ACM-ICPC-制备：ACM-ICPC制备指南
02-02
在计算机科学领域，ACM国际大学生程序设计竞赛（ACM International Collegiate Programming Contest，简称ACM-ICPC）是一项备受瞩目的赛事，它挑战参赛者的编程技能、算法理解和团队协作能力。对于希望在ACM-ICPC中...
ACM-ACM-ICPC算法示例之Greedy-题解.zip
最新发布
02-25
本资料包“ACM_ACM-ICPC算法示例之Greedy_题解.zip”主要包含了关于贪心算法的实例解析和题解，旨在帮助参赛者理解和掌握这种算法的应用。 贪心算法的核心思想是在每一步决策时都采取在当前状态下最好或最优的选择...
ACM-ACM-ICPC算法示例之Hashing-题解.zip
02-25
压缩包中的"ACM_ACM-ICPC算法示例之Hashing_题解"很可能包含了多个具体的题目，每个题目都涉及到Hashing的某种应用场景或特定问题的解决方案。这些题目可能涵盖以下几个方面： 1. 完全碰撞：如何处理哈希表中出现的...
个人ACM-ICPC模板acm-icpc-master.zip
02-05
标题中的“个人ACM-ICPC模板acm-icpc-master.zip”指的是一个与ACM国际大学生程序设计竞赛（International Collegiate Programming Contest, ICPC）相关的个人开发的模板项目。这个压缩包很可能是参赛者或者教练为了...
2018 ICPC Asia Nakhon Pathom Regional Contest 部分题解
qq_34035720的博客
09-25 318
Problem D Bus Stop Time Limit 1 sec 题目大意：给你n个点，代表一条街上房子的坐标，问你至少修多少个公交车站可以覆盖所有房子（公交车站最多可以覆盖左右10公里） 样例一解释：可以在2那建一个，然后在200那建一个 样例二解释：在20那建一个，在80和200那各建一个 思路分析：我们建公交车站的时候要尽量建在中间，就例如样例二中的10和30，但其实我们可以不用考虑那么麻烦，我们可以先标记第一个房子的位置，然后找和第一个房子距离<=20的房子，因为车站可以覆盖左右各10
2018-2019 ACM-ICPC, Asia Dhaka Regional Contest 寒假自训第九场
ccsu_cat
02-09 1128
前些天拜年咕了，今天成功被fcy带飞了 B.Counting Inversion fcy代码： #include&lt;bits/stdc++.h&gt; #define rep(i,a,b) for(int i=a;i&lt;=b;i++) #define ll long long using namespace std; const int Mod=998244353; struct...
2018-2019 ACM-ICPC Asia Qingdao Regional Contest
banshen0201的博客
02-02 96
M：Function and Function 转载于:https://www.cnblogs.com/Dup4/p/10348586.html
D - Grid Coloring（思维）
qq_40859951的博客
06-19 284
题目链接：https://atcoder.jp/contests/arc080/tasks/arc080_b Problem Statement We have a grid withHHrows andWWcolumns of squares. Snuke is painting these squares in colors11,22,......,NN. Here, th...
Grid Coloring （动态规划）
碳酸钙的01妖精的博客
08-29 355
借鉴：https://www.cnblogs.com/clrs97/p/7841819.html #include&lt;cstdio&gt; typedef long long ll; const int N=40; int n,m,i,j,k; ll ans,f[N][N]; //f[i][j]表示考虑前i行，第i行前j个为B的种类，额，前0个有意思。 char a[N][N];...
2018-acmicpc-asia-nakhon-pathom-regional-contest -- Problem L Largest Allowed Area(暴力二分检验+高级读入挂)
CourierLo的博客
02-16 744
题目链接：没有 题目大意： 一个公司想买一块正方形的地建总部，奈何地皮到处有森林，公司无奈下决定，只好买一块正方型地，它最多含有一处森林，而且公司有的是钱，越大越好。 解题思路： 先维护一个二位前缀和数组记录1的和，行和列的范围都是1000，有T组数据，如果暴力遍历每个点，检验一个点时二分枚举边界长度，时间复杂度是O（T*(n^2) * log(n)），最大要跑2e8的数据。比赛时用scanf...
2018-2019 ACM-ICPC, Asia Seoul Regional Contest ( TV Show Game ）2-SAT
qq_41645482的博客
04-19 1636
花了几天时间肝了几道2-SAT的题。 越做题越会发现，这个东西挺模板的了解原理之后只要会建边基本上就做出来了（除非加什么花里胡哨的二分）。 这篇博客写一个Seoul区域赛场的一个2-SAT问题。 读者可以去codeforces.com的gym搜seoul然后倒数第二题就是这道题了。 首先我们捋一下2-SAT解决问题流程： 其实2-SAT细究的话，也就是个 Tarjan求强连通分量...
2018-2019 ACM-ICPC, Asia Shenyang现场赛C && CodeForces 101955C
一只小陀螺的博客
12-02 742
题意： n[1,50],k[1,50],p[1e8,1e9]. 求有多少 1 到 n 的排列满足：将前 k 个的数排列以后，最长上升子序列长度为 n−1 以上。 瞎搞： 用next_permutation打表，然后肉眼找出规律。 打表代码。 #include &lt;bits/stdc++.h&gt; #define mem(sx, sy) memset(sx, sy, sizeof...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值