2018 Spring Training 数据结构

最新推荐文章于 2022-05-30 19:16:53 发布

HumveeA6

最新推荐文章于 2022-05-30 19:16:53 发布

阅读量230

点赞数

分类专栏：数据结构夏季训练合集系列 BoooomUPT

本文链接：https://blog.csdn.net/HumveeA6/article/details/80583096

版权

数据结构同时被 3 个专栏收录

12 篇文章 0 订阅

订阅专栏

BoooomUPT

5 篇文章 0 订阅

订阅专栏

夏季训练合集系列

4 篇文章 0 订阅

订阅专栏

这次的题目不少难度还是挺大的，对萌新挺不友好哇233…只会做一部分了2333
基本上就是，要么不会做，要么会做不想写贼复杂那种…

A.BZOJ1007
可以观察到，我们要求的是一个凹形的图形。
首先，我们先按k升序为第一关键字，b降序为第二关键字，然后用一个单调栈（单调队列）来维护这些直线。
若当前直线i能完全覆盖栈顶直线s[top]，也就是上一条加进去的直线（不一定是第一条直线哦），则i与s[top]的交点一定在s[top]与s[top-1]的交点左边或者重合。若在它左边或者重合，则弹出栈顶，直到交点在右边后，扔进栈里。最后栈中元素就是答案。
并不需要考虑太多精度问题；

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N=50005;
struct line{
    int a,b,id;
    bool operator<(const line&A)const{
        if(a==A.a)return b>A.b;
        return a<A.a;
    }
}G[N];
bool visable[N];
double getpos(int x,int y)
{
    return (double)(G[y].b-G[x].b)/(G[x].a-G[y].a);
}
int main()
{
    int n,i,j;
    //deque<int>que;
    int sta[N];
    cin>>n;
    for(i=1;i<=n;i++)cin>>G[i].a>>G[i].b,G[i].id=i;
    sort(G+1,G+1+n);
    //que.push_back(1);
    int top=1;sta[1]=1;
    for(i=2;i<=n;i++){
        if(G[i].a-G[i-1].a<1e-8)continue;
        //deque<int>::iterator iter;
        while(top>1&&getpos(i,sta[top])<=getpos(sta[top],sta[top-1]))top--;
        sta[++top]=i;
    }
    for(i=1;i<=top;i++)
        visable[G[sta[i]].id]=true;
    for(i=1;i<=n;i++)
        if(visable[i])cout<<i<<' ';

    return 0;
}

B.BZOJ1047
题目可以用单调队列来维护，先每一行扫一次，找出每一行的连续n个数的最大最小值，然后每一列扫一次，利用之前的结果，找出每个n*n矩阵的最大最小值。有一些细节需要注意，同时，也要理解单调队列的原理..否则估计就搞不懂为什么要用deque而不是queue…

#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1005;
typedef pair<int,int>P;
int main()
{
    int a,b,n,i,j,k;
    cin>>a>>b>>n;
    int num[N][N],maxn[N][N],minn[N][N];
    for(i=1;i<=a;i++)
        for(j=1;j<=b;j++)
            scanf("%d",&num[i][j]);
    for(i=1;i<=a;i++){//先每行扫一遍,存每连续n个数的最大最小值
        deque<P>que1,que2;
        for(j=1;j<n;j++){
            while(que1.size()&&(que1.back().first<num[i][j]))que1.pop_back();
            que1.push_back(P(num[i][j],j));
            while(que2.size()&&que2.back().first>num[i][j])que2.pop_back();
            que2.push_back(P(num[i][j],j));
            //maxn[i][j]=que1.front().first;minn[i][j]=que2.front().first;
        }
        for(j=n;j<=b;j++){
            while(que1.size()&&(que1.back().first<num[i][j]))que1.pop_back();
            que1.push_back(P(num[i][j],j));
            while(que2.size()&&(que2.back().first>num[i][j]))que2.pop_back();
            que2.push_back(P(num[i][j],j));
            while (que2.front().second < j-n+1) que2.pop_front();
            while (que1.front().second < j-n+1) que1.pop_front();
            maxn[i][j]=que1.front().first;minn[i][j]=que2.front().first;
        }
    }
    int gmax[N][N],gmin[N][N];int maxnum=0,minnum=(1<<31)-1;
    for(j=1;j<=b;j++){//竖着再来一遍
        deque<P>que1,que2;
        for(i=1;i<n;i++){
            while(que1.size()&&(que1.back().first<maxn[i][j]))que1.pop_back();
            que1.push_back(P(maxn[i][j],i));
            while(que2.size()&&que2.back().first>minn[i][j])que2.pop_back();
            que2.push_back(P(minn[i][j],i));
            //maxn[i][j]=que1.front().first;minn[i][j]=que2.front().first;
        }
        for(i=n;i<=a;i++){
            while(que1.size()&&(que1.back().first<maxn[i][j]))que1.pop_back();
            que1.push_back(P(maxn[i][j],i));
            while(que2.size()&&(que2.back().first>minn[i][j]))que2.pop_back();
            que2.push_back(P(minn[i][j],i));
            while (que2.front().second < i-n+1) que2.pop_front();
            while (que1.front().second < i-n+1) que1.pop_front();
            gmax[i][j]=que1.front().first;gmin[i][j]=que2.front().first;
            //minnum=min(minnum,que1.front().first-que2.front().first);
        }
    }
    for(i=n;i<=a;i++)
        for(j=n;j<=b;j++){
        minnum=min(minnum,gmax[i][j]-gmin[i][j]);
    }
    cout<<minnum<<endl;

    return 0;
}

C.HDU1512
左偏树的模板，我也没啥好说的…这玩意儿不大会用

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
int mo[4][2]={0,1,1,0,0,-1,-1,0};
const int MAXN=0x3f3f3f3f;
const int sz=100005;
int n,m;
struct node{
    ll val,lc,rc,dis,par;
}t[sz];

void init(){
    for(int i=1;i<=n;i++){
        t[i].lc=t[i].rc=t[i].dis=0;
        t[i].par=i;
    }
}

int fid(int x){
    if(t[x].par==x) return x;
    else return t[x].par=fid(t[x].par);
}

int same(int x,int y){
    return fid(x)==fid(y);
}

int mer(int x,int y){
    if(x==0) return y;
    if(y==0) return x;
    if(t[x].val<t[y].val) swap(x,y);
    t[x].rc=mer(t[x].rc,y);
    t[t[x].rc].par=x;
    if(t[t[x].lc].dis<t[t[x].rc].dis)
        swap(t[x].lc,t[x].rc);
    if(t[x].rc==0)
        t[x].dis=0;
    else
        t[x].dis=t[t[x].rc].dis+1;
    return x;
}

int pop(int x){
    int l=t[x].lc,r=t[x].rc;
    t[x].lc=t[x].rc=t[x].dis=0;
    t[l].par=l;t[r].par=r;
    return mer(l,r);
}

int main()
{
    int a,b,c,d,tmp;
    //freopen("r.txt","r",stdin);
    while(scanf("%d",&n)!=EOF){
        for(int i=1;i<=n;i++){
            scanf("%d",&t[i].val);
        }
        init();
        scanf("%d",&m);
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a,&b);
            if(same(a,b)){
                printf("-1\n");
            }else{
                c=t[a].par,d=t[b].par;
                a=pop(c);b=pop(d);
                t[c].val/=2;
                t[d].val/=2;
                tmp=mer(a,b);
                tmp=mer(tmp,c);
                tmp=mer(tmp,d);
                printf("%d\n",t[tmp].val);
            }
        }
    }
    return 0;
}

F.HDU1556
树状数组区间更新单点查询的板子题

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
typedef long long ll;
const int maxn = 100050;
int a[maxn], c[maxn],n;
int sum(int i)
{
    int s = 0;
    while (i) {
        s += c[i];
        i -= i&-i;
    }
    return s;
}
void add(int i, int x)
{
    while (i <= n) {
        c[i] += x;
        i += i&-i;
    }
}
int main(void)
{
    int i,j,k,a,b;
    while(cin>>n&&n){
        memset(c,0,sizeof(c));
        for(i=1;i<=n;i++){
            scanf("%d%d",&a,&b);
            add(a,1);add(b+1,-1);
        }
        for(i=1;i<=n;i++)
            printf("%d%c",sum(i),i==n?'\n':' ');
    }

    return 0;
}

G.BZOJ1878
这个题目棘手的地方在于，求的是不同贝壳的种类，也就是说，相同种类的贝壳只能算一次。如果用区间和的话，就会导致重复计算。
因此我们可以把所有询问进行离线处理，把所有询问按照右边界从小到大排序，右边界相同时则按左边界从小到大排序。然后建立一个指针，对于每次询问，如果指针位置比询问的右边界小，那么就从指针位置一直扫到右边界的位置，在此过程中扫到的元素如果之前出现过了，那么就在上一次出现的位置-1。然后在当前位置+1 即可，这样一定能保证区间内的所有你元素都只在最后一次出现的位置+1；

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
int bit[500005],n,m;
typedef long long ll;
int sum(int i)
{
    int s=0;
    while(i){
        s+=bit[i];
        i-=i&-i;
    }
    return s;
}
void add(int i,int x)
{
    while(i<=n){
        bit[i]+=x;
        i+=i&-i;
    }
}
struct query{
    int l,r,id;
    bool operator<(const query&a)const{
        if(r==a.r)return l<a.l;
        return r<a.r;
    }
}G[200005];
typedef pair<int,int>P;
vector<P>ans;
int exist[1000005];
int num[500005];
int main()
{
    int i,j,k;
    cin>>n;
    for(i=1;i<=n;i++){
        scanf("%d",&num[i]);
    }
    cin>>m;
    for(i=1;i<=m;i++){
        scanf("%d%d",&G[i].l,&G[i].r);G[i].id=i;
    }
    sort(G+1,G+1+m);int point=1;
    for(i=1;i<=m;i++){
        while(point<=G[i].r){
            if(exist[num[point]]){
                add(exist[num[point]],-1);exist[num[point]]=point;
            }
            else exist[num[point]]=point;
            add(point,1);
            point++;
        }
        ans.push_back(P(G[i].id,sum(G[i].r)-sum(G[i].l-1)));
    }
    sort(ans.begin(),ans.end());
    for(i=0;i<ans.size();i++)
        printf("%d\n",ans[i].second);

    return 0;
}

H.BZOJ 1452
注意到c的范围只有[1,100]，考虑开100个二维树状数组，维护矩阵内某一个数字的计数。单次查询复杂度O(log2n×log2m)

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=305;
int n;
int c[maxn][maxn][105];
inline int lowbit(int t)
{
    return t&(-t);
}
void update(int x,int y,int v,int num)
{
    for (int i=x; i<=n; i+=lowbit(i))
        for (int j=y; j<=n; j+=lowbit(j))
            c[i][j][num]+=v;
}
int query(int x,int y,int num)
{
    int s=0;
    for (int i=x; i>0; i-=lowbit(i))
        for (int j=y; j>0; j-=lowbit(j))
            s+=c[i][j][num];
    return s;
}
int sum(int x,int y,int xx,int yy,int num)
{
    x--,y--;
    return query(xx,yy,num)-query(xx,y,num)-query(x,yy,num)+query(x,y,num);
}
int main()
{
    int m,i,j,k,num[maxn][maxn];
    cin>>n>>m;
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++){
        scanf("%d",&k);update(i,j,1,k);num[i][j]=k;
    }
    int q;cin>>q;
    while(q--){
        int oper;scanf("%d",&oper);
        if(oper==1){
            int x,y,c;scanf("%d%d%d",&x,&y,&c);
            update(x,y,-1,num[x][y]);//记得把原来这个位置上的数-1
            num[x][y]=c;update(x,y,1,c);
        }
        else{
            int x1,x2,y1,y2,c;scanf("%d%d%d%d%d",&x1,&x2,&y1,&y2,&c);
            printf("%d\n",sum(x1,y1,x2,y2,c));
        }
    }

    return 0;
}

I.Codeforces Round #198 (Div. 1) D
　　想办法维护(1,1)(x,y)的异或和，那么矩形区域的异或和就可以根据四个位置的异或和求出。由于异或操作比较特殊，在一个区域进行异或操作，那么这个区域的某个点的(1,1)(x,y)的异或和要么要异或上v，要么异或上0。这样，我们就可以利用二维树状数组，只进行单点更新就完成更新矩形区域的操作，另外，由于区域是否被更新跟奇偶性有关，因此跟据奇偶性来维护4种情况的树状数组。PS：更新操作还是挺巧妙的，利用了一点容斥原理的感觉。
（其实我不是特别理解2333）

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn=1005;
ll lowbit(ll x) { return x&-x; }
ll c[2][2][maxn][maxn];
void add(int x, int y, int val, int n)
{
    for(int i = x; i <= n; i += lowbit(i))
    {
        for(int j = y; j <= n; j += lowbit(j))
            c[x&1][y&1][i][j] ^= val;
    }
}
ll get(int x, int y)
{

    ll o = 0;
    for(int i = x; i; i -= lowbit(i))
    {
        for(int j = y; j; j -= lowbit(j))
            o ^= c[x&1][y&1][i][j];
    }
    return o;
}
int main()
{
    int n, m;
    cin >> n >> m;
    int op, x1, x2, y1, y2;
    ll val;
    while(m--)
    {
        scanf("%d%d%d%d%d", &op, &x1, &y1, &x2, &y2);
        if(op == 1)
        {
            val = 0;
            val ^= get(x2, y2);
            val ^= get(x1 - 1, y2);
            val ^= get(x2, y1 - 1);
            val ^= get(x1 - 1, y1 - 1);
            cout << val << endl;
        }
        else
        {
            cin >> val;
            add(x1, y1, val, n);
            add(x1, y2 + 1, val, n);
            add(x2 + 1, y1, val, n);
            add(x2 + 1, y2 + 1, val, n);
        }
    }
    return 0;
}

J.BZOJ1067
总的来说题目非常麻烦，而且坑也略多…
这里写图片描述

为了方便统计，我们可以把年份给映射一下，或者说离散化一下。
然后如果x年和y年是没有记录的话，就二分找出最接近他们的有记录的一年开始查询。
然后，如果想要查询某一年x是否有记录，一定不能if(!mp[x]) ！！，会加入很多第二个键值为0的错误信息！！应该mp.find(x)!=mp.end() ！！

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
typedef long long ll;
const int maxn = 50005;
ll array1[maxn], sum[maxn << 2];
void buildtree(int node, int begin, int end)
{
    if (begin == end) {
        sum[node] = array1[begin];
        return;
    }
    int m = (begin + end) >> 1;
    buildtree(node << 1, begin, m);
    buildtree(node << 1 | 1, m + 1, end);
    sum[node] = max(sum[node << 1], sum[node << 1 | 1]);
}
void update(int node, int ind, int change, int begin, int end)
{
    if (begin == end) {
        sum[node] = change;
        return;
    }
    int m = (begin + end) >> 1;
    if (ind <= m)
        update(node << 1, ind, change, begin, m);
    else
        update(node << 1 | 1, ind, change, m + 1, end);
    sum[node] = max(sum[node << 1], sum[node << 1 | 1]);
}
ll query(int node, int begin, int end, int left, int right)
{
    if (left <= begin&&right >= end)
        return sum[node];
    int m = (begin + end) >> 1;
    ll p1 = 0, p2 = 0;
    if (left <= m)
        p1 = query(node << 1, begin, m, left, right);
    if (right > m)
        p2 = query(node << 1 | 1, m + 1, end, left, right);
    return max(p1, p2);
}
int main()
{
    map<int,int>mp;
    int cnt=1;
    int n,m,i,j,k,y,r,x;
    cin>>n;
    for(i=1;i<=n;i++){
        scanf("%d%d",&y,&r);
        if(!mp[y])mp[y]=++cnt;
        array1[mp[y]]=r;
    }
    buildtree(1,1,cnt);
    cin>>m;
    for(i=1;i<=m;i++){
        scanf("%d%d",&y,&x);
        if(mp.find(x)!=mp.end()&&mp.find(y)!=mp.end()&&x-y+1==mp[x]-mp[y]+1){//y年和x年降雨量都已知
            if(array1[mp[x]]<=array1[mp[y]]&&query(1,1,cnt,mp[y]+1,mp[x]-1)<array1[mp[x]]){
                //X年的降雨量不超过Y年的降雨量且从Y+1到X-1年的降雨量都小于X年的降雨量
                puts("true");
            }
            else puts("false");
        }
        else if(mp.find(x)!=mp.end()&&mp.find(y)!=mp.end()&&array1[mp[x]]<=array1[mp[y]]){
            //Y年和X年的降雨量已知且X年的降雨量不超过Y年的降雨量
            if(x-y+1>mp[x]-mp[y]+1){//从Y+1到X-1年中存在至少一年的降雨量未知
                if(mp[x]-mp[y]==1)//如果这中间没有任何有记录的降雨量,当时是也许
                    puts("maybe");
                else{
                    if(query(1,1,cnt,mp[y]+1,mp[x]-1)<array1[mp[x]])//从Y+1到X-1年中已知的降雨量都小于X年的降雨量
                        puts("maybe");
                    else puts("false");
                }
            }
            else puts("false");
        }
        else if(((mp.find(x)==mp.end()&&mp.find(y)!=mp.end())||(mp.find(y)==mp.end()&&mp.find(x)!=mp.end()))){
            //Y年和X年中有且仅有一年的降雨量未知且从Y+1到X-1年中已知的降雨量都小于X年的降雨量
            map<int,int>::iterator iter;//需要分类讨论,否则query的时候没有记录的端点会出错
            if((mp.find(x)==mp.end()&&mp.find(y)!=mp.end())){
                iter=mp.lower_bound( x);iter--;
                if(query(1,1,cnt,mp[y]+1,iter->second)<array1[mp[y]])
                    puts("maybe");
                else puts("false");
            }
            else{
                iter=mp.lower_bound(y);
                if(query(1,1,cnt,iter->second,mp[x]-1)<array1[mp[x]]){
                    puts("maybe");
                }
                else puts("false");
            }
        }
        else if((mp.find(x)==mp.end()&&mp.find(y)==mp.end())){//Y年和X年的降雨量都未知
            puts("maybe");
        }
        else puts("false");
    }

    return 0;
}

O.Educational Codeforces Round 45 (Rated for Div. 2)
这里写图片描述
简单来说，就是题目并不是最长上升子序列。同时，朴素的O（n^2）的dp算法会tle，所有我们需要进行线段树优化。与官方题解类似，不过我写的时候是将蛋糕按编号从小到大插入，因为蛋糕插入的位置必须严格大于上一个蛋糕的体积，所以就在排好序的体积里找小于当前体积的最大值，然后在1~这个位置之间查询最大值并更新当前答案。题目有点绕，不是特别好理解。

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include <iomanip>
#include<cmath>
#include<vector>
using namespace std;
typedef long long ll;
const double pi=acos(-1);
const int maxn = 100005;
//int m, d, len = 0;
ll array1[maxn], t = 0, sum[maxn << 2];
void buildtree(int node, int begin, int end)
{
    if (begin == end) {
        sum[node] = array1[begin];
        return;
    }
    int m = (begin + end) >> 1;
    buildtree(node << 1, begin, m);
    buildtree(node << 1 | 1, m + 1, end);
    sum[node] = max(sum[node << 1], sum[node << 1 | 1]);
}
void update(int node, int ind, ll change, int begin, int end)
{
    if (begin == end) {
        sum[node] = change;
        return;
    }
    int m = (begin + end) >> 1;
    if (ind <= m)
        update(node << 1, ind, change, begin, m);
    else
        update(node << 1 | 1, ind, change, m + 1, end);
    sum[node] = max(sum[node << 1], sum[node << 1 | 1]);
}
ll query(int node, int begin, int end, int left, int right)
{
    if (left <= begin&&right >= end)
        return sum[node];
    int m = (begin + end) >> 1;
    ll p1 = 0, p2 = 0;
    if (left <= m)
        p1 = query(node << 1, begin, m, left, right);
    if (right > m)
        p2 = query(node << 1 | 1, m + 1, end, left, right);
    return max(p1, p2);
}
//struct Cake{
//    int id;ll vol;
//    bool operator<(const Cake&v)const{
//        if(vol==v.vol)
//            return id<v.id;
//        return vol<v.vol;
//    }
//}cake[maxn];
//typedef pair<ll,int>P;
//P cake[maxn];
ll cake[maxn];
ll f[maxn];
int main()
{
    int n,i,j,k;ll v[maxn];
    cin>>n;
    for(i=1;i<=n;i++){
        ll r,h;
        scanf("%lld%lld",&r,&h);
        v[i]=cake[i]=r*r*h;//cake[i].second=i;
    }
    sort(cake+1,cake+1+n);
//    for(i=1;i<=n;i++){
//        if(cake[i].vol==cake[i-1].vol){
//            j=i-1;
//            while(cake[i].vol==cake[j].vol){
//                cake[i].vol=0;i++;
//            }
//        }
//    }
    buildtree(1,1,n);
    ll ans=0;
    for(i=1;i<=n;i++){
        //if(!cake[i].vol)continue;
        int pos=lower_bound(cake+1,cake+1+n,v[i])-cake;
        if(pos==1)f[i]=v[i];
        else {
            ll maxn = query(1, 1, n, 1, pos-1);
            f[i] = maxn + v[i];
        }
        update(1, pos, f[i], 1, n);
        ans = max(ans, f[i]);
    }
    //printf("%lf\n",(double)ans*3.1415926535);
    cout << setprecision (20);
    cout<<ans*pi<<endl;

    return 0;
}