20190807

咕了很长时间了QAQ

T1. 旋转子段

　话说 n^2 思路也很棒....（对于想不到正解的我而言

　枚举中心点 mid ，长度 len，由小长度向大长度双向扩展. 其实离正解差一个结论，就是你的 旋转边界 旋转过后 一定能对答案做 1 个贡献.（要不你完全可以将区间左右同时缩小 即由 [ i , j ] 变为 [ i + 1 , j - 1 ] .）所有优秀区间一定满足上述条件. 所以可以根据 mid 分类，对于每一个 mid 执行上述扩展操作，并更新答案. 复杂度的话，由于只有 n 个上述符合条件的边界，加上 sort 共是 nlogn.

　

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#define QAQ 500010
#define re register
#define fup(i,a,b) for(re int i=a;i<=b;++i)
#define fdn(i,a,b) for(re int i=a;i>=b;--i)
#define mp(a,b) make_pair(a,b)
int n;
int sum[QAQ];
using namespace std;
std::vector< pair<int,int> >wtf[QAQ<<1];
inline int read() {
    re int x(0),f(1);re char ch=getchar();
    while(ch<'0'||ch>'9')   { if(ch=='-') f=-1; ch=getchar(); }
    while(ch>='0'&&ch<='9') { x=(x<<3)+(x<<1)+(ch^48); ch=getchar(); }
    return x*f;
}
int main() { n=read();
    fup(i,1,n) {
        re int l=read(),r=i;
        sum[i]=sum[i-1]+(l==r);
        if(l>r) swap(l,r);
        wtf[l+r].push_back(mp(r,l));
    }
    if(sum[n]==n) std::cout<<sum[n]<<std::endl,exit(0);
    re int ans=0;
    fup(i,1,n<<1) if(wtf[i].size()!=0) {
        std::sort(wtf[i].begin(),wtf[i].end());
        fup(j,0,wtf[i].size()-1) {
            re int l=wtf[i][j].second;
            re int r=wtf[i][j].first;
            ans=std::max(ans,sum[n]-sum[r]+sum[l-1]+j+1);
        }
    }
    std::cout<<ans<<std::endl;
}

---

T2. 走格子

　考试时根本没打，真没想到这么水...

　建图跑spfa就ojbk..

　考虑如何建图.

　首先相邻边可连，然后就是传送门的使用.

　可以发现最佳食用方法是由离自己当前位置最近的墙biu～然后穿过去，所以需要 bfs （或其他）处理离自己最近的墙，建当前位置经墙到别的位置的边.（话说这种题还真好玩虽然不善良

　

#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
#define QAQ 502
#define re register
#define fup(i,a,b) for(re int i=a;i<=b;++i)
#define fdn(i,a,b) for(re int i=a;i>=b;--i)
using namespace std;
int n,m,st,ed;
int     v[QAQ*QAQ];
int  diss[QAQ*QAQ];
char map[QAQ][QAQ];
int  dis[QAQ][QAQ];
int upto[QAQ][QAQ];
int lfto[QAQ][QAQ];
int rgto[QAQ][QAQ];
int dnto[QAQ][QAQ];
vector< pair<int, int> >wtf[QAQ*QAQ];
inline int read() {
    re int x(0),f(1);re char ch=getchar();
    while(ch<'0'||ch>'9')   { if(ch=='-') f=-1; ch=getchar(); }
    while(ch>='0'&&ch<='9') { x=(x<<3)+(x<<1)+(ch^48); ch=getchar(); }
    return x*f;
}
queue< pair<int, int> >qwq;
inline int Get_id(int x,int y) {
    return (x-1)*m+y;
}
inline void Try_push(int x,int y,int ds) {
    if(map[x][y]=='.'&&!dis[x][y])
    dis[x][y]=ds,qwq.push(make_pair(x,y));
}
int main() {
    n=read(),m=read();
    fup(i,1,n) scanf("%s",map[i]+1);
    fup(i,1,n) fup(j,1,m) {
        if(map[i][j]=='#') qwq.push(make_pair(i,j));
        if(map[i][j]=='C') map[i][j]='.',st=Get_id(i,j);
        else if(map[i][j]=='F') map[i][j]='.',ed=Get_id(i,j);
    }
    //while(!qwq.size())嘤？？？
    while(qwq.size()) {
        re int x=qwq.front().first;
        re int y=qwq.front().second;
        qwq.pop();
        Try_push(x+1,y,dis[x][y]+1);
        Try_push(x-1,y,dis[x][y]+1);
        Try_push(x,y+1,dis[x][y]+1);
        Try_push(x,y-1,dis[x][y]+1);
    }
    fup(i,1,n) fup(j,1,m) if(map[i][j]=='.') {
        if (map[i-1][j]=='#') upto[i][j]=Get_id(i,j);
        else upto[i][j]=upto[i-1][j];
        if (map[i][j-1]=='#') lfto[i][j]=Get_id(i,j);
        else lfto[i][j]=lfto[i][j-1];
    }
    fdn(i,n,1) fdn(j,m,1) if(map[i][j]=='.') {
        if (map[i+1][j]=='#') dnto[i][j]=Get_id(i,j);
        else dnto[i][j]=dnto[i+1][j];
        if (map[i][j+1]=='#') rgto[i][j]=Get_id(i,j);
        else rgto[i][j]=rgto[i][j+1];
    }
    fup(i,1,n) fup(j,1,m) if(map[i][j]=='.') {
        if (map[i][j+1]=='.') wtf[Get_id(i,j)].push_back(make_pair(Get_id(i,j+1),1)),
                              wtf[Get_id(i,j+1)].push_back(make_pair(Get_id(i,j),1));
        if (map[i+1][j]=='.') wtf[Get_id(i,j)].push_back(make_pair(Get_id(i+1,j),1)),
                                   wtf[Get_id(i+1,j)].push_back(make_pair(Get_id(i,j),1));
        if (upto[i][j]!=Get_id(i,j)) wtf[Get_id(i,j)].push_back(make_pair(upto[i][j],dis[i][j]));
        if (dnto[i][j]!=Get_id(i,j)) wtf[Get_id(i,j)].push_back(make_pair(dnto[i][j],dis[i][j]));
        if (lfto[i][j]!=Get_id(i,j)) wtf[Get_id(i,j)].push_back(make_pair(lfto[i][j],dis[i][j]));
        if (rgto[i][j]!=Get_id(i,j)) wtf[Get_id(i,j)].push_back(make_pair(rgto[i][j],dis[i][j]));
    }
    memset(diss,0x3f,sizeof diss);
    memset(v,0,sizeof v);diss[st]=0;
    queue<int>qaq;
    qaq.push(st),v[st]=1;
    while(qaq.size()) {
        re int x=qaq.front();
        qaq.pop();v[x]=0;
        if (wtf[x].size())
        fup(i,0,wtf[x].size()-1) {
            re int y=wtf[x][i].first;
            re int d=wtf[x][i].second;
            if (diss[y]>diss[x]+d) {
                diss[y]=diss[x]+d;
                if (v[y])continue;
                qaq.push(y),v[y]=1;
            }
        }
    }
    printf("%d\n",diss[ed]);
}

---

T3. 柱状图

我才不会说我和上次T1一样推了半年的柿子QAQ（最后5分钟打了个过不了样例的暴力骗到了15分　

　然而正解和数学柿子没卵关系嘤

　首先这是一个单谷函数

设 f(x) 代表最高柱子高度为 x 时的调整所需花费。显然，当 x 取到一个恰当的值的时候，可以使得花费最小，当然，这样的值可能有很多个。但是不难发现只要任何一个其他的x'不能取得更优的值，就可以保证这是一个单谷函数(由于相邻的柱子高度差只能为1)(w又颓的网上证明

　所以可以三分.

　所以枚举最高点，三分高度并判定 就可以 n^2logn 得到 60 分的好成绩.....

　考虑如何优化 三分求解时利用两个树状数组来维护最高点两边的关键值，然后利用树状数组的求前缀和功能计算花费即可

　$\left [ cnt_l*(h_x-x)-\sum_{i=1}^{pos}(h_i-i) \right ] + \left [ \sum_{i=pos+1}^{n}(h_i-i)-cnt_r*(h_x-x) \right ]$

　以上为左侧

　$\left [ cnt_l*(h_x+x)-\sum_{i=1}^{pos}(h_i+i) \right ] + \left [ \sum_{i=pos+1}^{n}(h_i+i)-cnt_r*(h_x+x) \right ]$

　以上为右侧

　cntl 为关键值小于 h[x]-x ( h[x]+x ) 并且下标也小于 x 的数量  cntr关键值大于 h[x]-x ( h[x]+x ) 并且下标也小于 x 的数量

　

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define QAQ 100005
#define re register
#define int long long
#define lowbit(x) x&-x
#define pait pair<int,int>
#define mp(a,b) make_pair(a,b)
#define fup(i,a,b) for(re int i=a;i<=b;++i)
#define fdn(i,a,b) for(re int i=a;i>=b;--i)
using namespace std;
int n,ans,a[QAQ],rkl[QAQ],rkr[QAQ];
inline int read() {
    re int x(0),f(1);re char ch=getchar();
    while(ch<'0'||ch>'9')   { if(ch=='-') f=-1; ch=getchar(); }
    while(ch>='0'&&ch<='9') { x=(x<<3)+(x<<1)+(ch^48); ch=getchar(); }
    return x*f;
}
struct node {
    int val,id;
    friend bool operator < (node a,node b) {
        return a.val < b.val;
    }
}l[QAQ],r[QAQ];
pait operator + (pait a,pait b) {
    return mp(a.first+b.first,a.second+b.second);
}
pait operator - (pait a,pait b) {
    return mp(a.first-b.first,a.second-b.second);
}
struct tree {
    int sum[QAQ],cnt[QAQ];
    inline void insert(re int x,pait now) {
        for(;x<=n;x+=lowbit(x))
            sum[x]+=now.first,
            cnt[x]+=now.second;
    }
    inline pait query_val(re int x) {
        pait ans=mp(0,0);
        for(;x;x-=lowbit(x)) 
            ans=ans+mp(sum[x],cnt[x]);
        return ans;
    }
    inline pait query_line(re int l,re int r) {
        if(l>r) return mp(0,0);
        return query_val(r)-query_val(l-1);
    }
}Right,Left;
int find(node *what,re int dat) {
    re int l=1,r=n,mid;
    while(mid=l+r>>1,l+1<r) {
        if(what[mid].val>dat) r=mid;
        else l=mid;
    }
    if(what[r].val<=dat) return r;
    if(what[l].val<=dat) return l;
    return 0;
}
int calc(re int id,re int high) {
    re int res=abs(high-a[id]);re pait cost;
    re int pos=find(l,high-id);
    cost=Left.query_val(pos);
    res+=(high-id)*cost.second-cost.first;
    cost=Left.query_line(pos+1,n);
    res+=cost.first-(high-id)*cost.second;
    pos=find(r,high+id);
    cost=Right.query_val(pos);
    res+=(high+id)*cost.second-cost.first;
    cost=Right.query_line(pos+1,n);
    res+=cost.first-(high+id)*cost.second;
    return res;
}
main() {
    n=read();re int maxx=0,ans=0x7f7f7f7f7f7f7f7f;
    fup(i,1,n) a[i]=read(),maxx=max(maxx,a[i]);
    fup(i,1,n)
        l[i]=(node){ a[i] - i, i },
        r[i]=(node){ a[i] + i, i };
    sort(l+1,l+n+1),sort(r+1,r+n+1);
    fup(i,1,n)
        rkl[l[i].id] = i,
        rkr[r[i].id] = i;
    fup(i,1,n) Right.insert(rkr[i],mp(r[rkr[i]].val,1));
    fup(i,1,n) {
        Right.insert(rkr[i],mp(-r[rkr[i]].val,-1));
        re int ll=max(i,n-i+1),rr=maxx+n;
        while(ll+1<rr){
            re int mid=(ll+rr)>>1;
            if(calc(i,mid-1)>=calc(i,mid))  ll=mid;
            else  rr=mid;
        }
        ans=min(ans,calc(i,ll));  ans=min(ans,calc(i,rr));
        Left.insert(rkl[i],mp(l[rkl[i]].val,1));
    } std::cout<<ans<<std::endl;
}

 

（话说为什么不打模拟退火呢？