8.7 NOIP模拟测试14 旋转子段+走格子+ 柱状图

T1 旋转子段

30% 暴力枚举起点和长度，暴力判断，o（n³）  不知道为什么我拿了40分。。。

60% 每一个点都有一个固定的旋转中心可以转成固定点，枚举旋转点和长度。

100% 用一个vector存一下以此点为旋转中心，可以将哪些点转成好点，存区间的左右端点（i，a[i]），将区间长度从小到大排序，枚举中间点，再枚举以他为中心可以将哪些点转成固定点，由于按区间长度排序了，所以第几个点+1就是旋转后当前区间有的固定点个数。区间左右的用前缀和计算即可。

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int n,ans,a[],q[];
vector< pair<int,int> >ve[];
int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++){
        scanf("%d",&a[i]);
        q[i]=q[i-];
        if(a[i]==i) q[i]++;
        ve[a[i]+i].push_back(make_pair(max(a[i],i),min(a[i],i)));
    }
    if(q[n]==n){
        printf("%d\n",n);
        return ;
    }
    for(int i=;i<=*n;i++){
        sort(ve[i].begin(),ve[i].end());
        for(int j=;j<ve[i].size();j++){
            int r=ve[i][j].first,l=ve[i][j].second;
            ans=max(ans,j++q[l-]+q[n]-q[r]);
        }
    }
    printf("%d\n",ans);
}

旋转子段

T2 走格子

将网格抽象成图，建边，跑dj或spfa。知道建边就好做了，可是我想不到。。。。

需要建的边 一种是空格和空格之间的  一种是穿墙。

第一种直接暴力建就行了。第二种找到离空格最近的墙，到其他墙前的空格的步数为 最近墙+1

最近的墙可以lowerbound二分查找，也可以bfs：从墙往空地扩展，dis[][]中存的就是到最近墙的距离，具体是哪面不重要。

每个空地穿墙后到达的空地，可以o（n×m）扫一遍，他就挨着墙，那么他的位置就是答案，其他的只需要继承前一个的就行。

穿墙到达空地这时需要建单向边，因为从这个空能到这面墙前，这面墙的空地不一定能到达那个空地。因为这个wa了好久，其他的相邻的空地之间是双向边。

主要是要想到将网格之间的可行路建边。

#include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;
struct node
{
    int to,nxt,w;
}h[];
int n,m,a[][],ex,ey,sx,sy,tot,nxt[],d[][],lq[][],rq[][],uq[][],dq[][];
int dis[];
char ch[];
queue< pair<int,int> > q;
bool vis[][],v[];
void add(int x,int y,int w)
{
    h[++tot].to=y;
    h[tot].nxt=nxt[x];
    h[tot].w=w;
    nxt[x]=tot;
}
int getpos(int x,int y)
{
    return (x-)*m+y;
}
void ad(int x,int y,int ds)
{
    if(a[x][y]){
        if(ds<=d[x][y]){
            d[x][y]=ds;
            if(!vis[x][y]){
                q.push(make_pair(x,y));
                vis[x][y]=;
            }
        }
    }
}
void bfs()
{
    while(q.size()){
        int x=q.front().first,y=q.front().second;
        q.pop();vis[x][y]=;
        ad(x-,y,d[x][y]+);
        ad(x+,y,d[x][y]+);
        ad(x,y-,d[x][y]+);
        ad(x,y+,d[x][y]+);
    }
}
void init()
{
    for(int i=n;i>=;i--){
        for(int j=m;j>=;j--){
            if(a[i][j]){
                if(!a[i+][j]) dq[i][j]=getpos(i,j);
                else dq[i][j]=dq[i+][j];
                if(!a[i][j+]) rq[i][j]=getpos(i,j);
                else rq[i][j]=rq[i][j+];
            }
        }
    }
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            if(a[i][j]){
                if(!a[i-][j]) uq[i][j]=getpos(i,j);
                else uq[i][j]=uq[i-][j];
                if(!a[i][j-]) lq[i][j]=getpos(i,j);
                else lq[i][j]=lq[i][j-];
            }
        }
    }
}
void build()
{
    for(int i=;i<=n;i++){
        for(int j=;j<=m;j++){
            if(a[i][j]){
                if(a[i-][j]) add(getpos(i,j),getpos(i-,j),);
                if(a[i+][j]) add(getpos(i,j),getpos(i+,j),);
                if(a[i][j-]) add(getpos(i,j),getpos(i,j-),);
                if(a[i][j+]) add(getpos(i,j),getpos(i,j+),);
                if(lq[i][j]!=getpos(i,j)) add(getpos(i,j),lq[i][j],d[i][j]);
                if(rq[i][j]!=getpos(i,j)) add(getpos(i,j),rq[i][j],d[i][j]);
                if(uq[i][j]!=getpos(i,j)) add(getpos(i,j),uq[i][j],d[i][j]);
                if(dq[i][j]!=getpos(i,j)) add(getpos(i,j),dq[i][j],d[i][j]);
            }

        }
    }
}
void spfa()
{
    queue<int> qq;
    memset(dis,0x3f,sizeof(dis));
    qq.push(getpos(sx,sy));
    dis[getpos(sx,sy)]=;
    v[getpos(sx,sy)]=;
    while(qq.size()){
        int x=qq.front();qq.pop();v[x]=;
        for(int i=nxt[x];i;i=h[i].nxt){
            int y=h[i].to;
            if(dis[y]>=dis[x]+h[i].w){
                dis[y]=dis[x]+h[i].w;
                if(!v[y]){
                    v[y]=;
                    qq.push(y);
                }
            }
        }
    }
}
int main()
{
    memset(d,0x3f,sizeof(d));
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++){
        scanf("%s",ch+);
        for(int j=;j<=m;j++){
            if(ch[j]=='.') a[i][j]=;
            else if(ch[j]=='C') sx=i,sy=j,a[i][j]=;
            else if(ch[j]=='F') ex=i,ey=j,a[i][j]=;
            else{
                q.push(make_pair(i,j));
                vis[i][j]=;
                d[i][j]=;
            }
        }
    }
    bfs();init();build();spfa();
    if(dis[getpos(ex,ey)]>=){
        puts("no");
        return ;
    }
    printf("%d\n",dis[getpos(ex,ey)]);
    return ;
}

走格子

T3 柱状图此题不可做。。。

首先，以一个点为最高点，那么需要变动的高度是一个单谷的函数，所以三分答案。

我们可以O（n）枚举以谁为最高点，O（logn）三分最高点的高度，O（n）计算答案，总复杂度O（n²logn）。可以得到60分的好成绩。

其实这个思路已经很接近正解了。枚举最高点和三分高度无法优化（skyh的三分答案+退火我不做任何评价，因为我不会），那么就只能对计算答案下手了。

我们确定了最高点（x 枚举）和最高高度（h[x] 三分）那么图形的形状就是确定的了。

设i为x左边的一个点，应该的高度为h[i]，原始高度为a[i];

h[i]=h[x]-abs(i-x)  去绝对值得 h[i]-i=h[x]-x 他需要改变的高度Δh=abs(h[i]-a[i])=abs( (h[i]-i)-(a[i]-i) )=abs( (h[x]-x)-(a[i]-i) )

再次分类去绝对值 (h[x]-x)>(a[i]-i) Δh=(h[x]-x)-(a[i]-i)

那么我们设满足i<x&&(h[x]-x)>(a[i]-i) 有cnt个，他们对答案的贡献为cnt×(h[x]-x)-Σ(a[i]-i)

cnt和(a[i]-i)可以用两个树状数组维护：将(a[i]-i)和i当做二元组存起来，按a[i]-i的大小进行排序，得到每个点在数组中的位置。用现在的位置当作树状数组的下标，维护(a[i]-i)的和 和cnt的个数。因为我们是从左往右扫，扫完一个点才会把他对应的值加入树状数组，所以当前树状数组中的值都是满足i<x的。那么我们只需要找到(a[i]-i)<=(h[x]-x)的最后一个位置pos。二分找到这个位置（排序后的数组）,他对应的下标就是树状数组中下标的位置。

同理(a[i]-i)>(h[x]-x)的情况 Σ(a[i]-i)-cnt×(h[x]-x) 只需要查询到n的，然后减去pos以前的，剩下的就是我们想要的。

在x右边的也一样，h[i]+i=h[x]+x，其他的一样维护。

这题一共4个树状数组。。。。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#define ll long long
using namespace std;
ll n,ans,mm,a[],idl[],idr[];
pair<ll,ll> l[],r[];
struct node
{
    ll c[],cc[];
    ll lowbit(ll x)
    {
        return x&(-x);
    }
    void add(ll x,ll w,ll num){
        while(x<=n){
            c[x]+=w;
            cc[x]+=num;
            x+=lowbit(x);
        }
    }
    pair<ll,ll> query(ll x)
    {
        pair<ll,ll> as;
        while(x){
            as.first+=c[x];
            as.second+=cc[x];
            x-=lowbit(x);
        }
        return as;
    }
}L,R;
ll calc(ll x,ll height)
{
    ll res=abs(a[x]-height);
    ll pos=upper_bound(l+,l+n+,make_pair(height-x,1ll))-l-;
    pair<ll,ll> cost=L.query(pos);
    res+=cost.second*(height-x)-cost.first;
    pair<ll,ll> cst=L.query(n);
    cst.first-=cost.first;cst.second-=cost.second;
    res+=cst.first-cst.second*(height-x);

    pos=upper_bound(r+,r+n+,make_pair(height+x,1ll))-r-;
    cost=R.query(pos);
    res+=cost.second*(height+x)-cost.first;
    cst=R.query(n);
    cst.first-=cost.first;cst.second-=cost.second;
    res+=cst.first-cst.second*(height+x);
    return res;
}
void work()
{
    for(ll i=;i<=n;i++) R.add(idr[i],r[idr[i]].first,);
    for(ll i=;i<=n;i++){
        R.add(idr[i],-r[idr[i]].first,-);
        ll lb=max(i,n-i+),rb=mm+n;
        while(lb+<rb){
            ll mid=(lb+rb)>>;
            ll lmid=mid-,rmid=mid;
            ll lcost=calc(i,lmid),rcost=calc(i,rmid);
            if(lcost>=rcost) lb=mid;
            else rb=mid;
        }
        ans=min(ans,calc(i,lb));
        ans=min(ans,calc(i,rb));
        L.add(idl[i],l[idl[i]].first,);
    }
}
int main()
{
    scanf("%lld",&n);ans=0x7ffffffffffffff;
    for(ll i=;i<=n;i++){
        scanf("%lld",&a[i]);
        mm=max(mm,a[i]);
        l[i]=make_pair(a[i]-i,i);
        r[i]=make_pair(a[i]+i,i);
    }
    sort(l+,l+n+);
    sort(r+,r+n+);
    for(ll i=;i<=n;i++){
        idl[l[i].second]=i;
        idr[r[i].second]=i;
    }
    work();
    printf("%lld\n",ans);
    return ;
}

柱状图

改了一下午。。。树状数组的下标理解错了，怎么都不知道是怎么维护的。