NOIP模拟测试14

考完19了再写14，我也是够咕的。

14的题很好，也充分暴露了我的问题。

T1是个分析性质推结论的题

对于区间[L,R]，不妨设a[L]!=a[R]，那么两个端点对答案没有贡献，也就是[L+1,R],[L,R-1]都是符合题意的区间。

即 最优的区间的两个端点一定相等

然后把每个数的位置和大小作为区间的两端点，统计答案即可。

#include<bits/stdc++.h>
#define F(n) for(int i=1;i<=n;i++)
int a[500005],sum[500005],n,ans;
std::vector< std::pair<int,int> >k[500005<<1];
int main(){
    scanf("%d",&n);
    F(n)scanf("%d",&a[i]),sum[i]=sum[i-1]+(a[i]==i);ans=sum[n];
    F(n)k[a[i]+i].push_back(std::make_pair(std::min(i,a[i]),std::max(i,a[i])));
    F((n<<1))sort(k[i].begin(),k[i].end());
    F((n<<1))
        for(int t=k[i].size(),j=t-1,last=0;j>=0;j--,last++)
            ans=std::max(ans,last+1+sum[k[i][j].first-1]+sum[n]-sum[k[i][j].second]);
    std::cout<<ans;
}

T2走格子

关键在于如何将题目抽象成图论模型，而不是只一味的搜索。

这道题没有太多的限制，只有移动到每个格子的距离的不同。

因此直接建边，跑dijstra即可

#include<bits/stdc++.h>
#define MAXN 505
using namespace std;
const int h[5]={0,1,-1,0,0},l[5]={0,0,0,1,-1};
int mp[MAXN][MAXN],endx,endy,n,m,tot=0;
priority_queue<pair<int,int> >Q;
vector<int>zh[MAXN],zl[MAXN];
bool vst[MAXN*MAXN];
int ans=0x7f7f7f7f,stax,stay;
int p[MAXN][MAXN],d[MAXN*MAXN],nxt[MAXN*MAXN*100],val[MAXN*MAXN*100],to[MAXN*MAXN*100],cnt,head[MAXN*MAXN];
void add(int u,int v,int w)
{
    to[++cnt]=v;nxt[cnt]=head[u];head[u]=cnt;val[cnt]=w;
    return ;
}
int dijstra()
{
    memset(d,0x3f,sizeof(d));d[p[stax][stay]]=0;
    Q.push(make_pair(0,p[stax][stay]));
    while(Q.size())
    {
        int k=Q.top().second;Q.pop();
        if(k==p[endx][endy])return d[k];
        if(vst[k])continue;
        vst[k]=1;
        for(int i=head[k];i;i=nxt[i])
        {
            int y=to[i];
            if(d[y]>d[k]+val[i])
            {
                d[y]=d[k]+val[i];
                Q.push(make_pair(-d[y],y));
            }
        }
    }
    return 0x7f7f7f7f;
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            p[i][j]=++tot;
            char c=getchar();
            while(c!='C'&&c!='F'&&c!='.'&&c!='#')c=getchar();
            if(c=='C')stax=i,stay=j,mp[i][j]=1;
            else if(c=='F')endx=i,endy=j,mp[i][j]=1;
            else if(c=='.')mp[i][j]=1;
            else mp[i][j]=0;
        }
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(!mp[i][j])zh[i].push_back(j);
    for(int j=1;j<=m;j++)
        for(int i=1;i<=n;i++)
            if(!mp[i][j])zl[j].push_back(i);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            if(!mp[i][j])continue;
            if(i^1&&mp[i-1][j])add(p[i][j],p[i-1][j],1);
            if(i^n&&mp[i+1][j])add(p[i][j],p[i+1][j],1);
            if(j^1&&mp[i][j-1])add(p[i][j],p[i][j-1],1);
            if(j^m&&mp[i][j+1])add(p[i][j],p[i][j+1],1);
            int up=*(--lower_bound(zl[j].begin(),zl[j].end(),i));
            int down=*(lower_bound(zl[j].begin(),zl[j].end(),i));
            int lef=*(--lower_bound(zh[i].begin(),zh[i].end(),j));
            int rig=*(lower_bound(zh[i].begin(),zh[i].end(),j));
            int dis=min(i-up,min(down-i,min(j-lef,rig-j)));
            add(p[i][j],p[up+1][j],dis);
            add(p[i][j],p[down-1][j],dis);
            add(p[i][j],p[i][lef+1],dis);
            add(p[i][j],p[i][rig-1],dis);
        }
    ans=dijstra();
    if(ans==0x7f7f7f7f)cout<<"no"<<endl;
    else cout<<ans<<endl;
    return 0;
}

T3柱状图  好题标记

这道题考察的是三分。

观察一下可知对于某一位置来说，其高度大小与最终答案的关系是单谷的。

（当你得到一个最优答案的时候，如果变大会使其余的柱子在原基础上再上升一个，反之亦然）

于是60分做法诞生：

枚举位置，三分高度，统计答案   O(n^2logn)

#include<bits/stdc++.h>
#define MAXN 100005
#define int long long
#define F(x) for(int i=1;i<=n;i++)
#define re register
#define min(a,b) (a)<(b)?(a):(b)
using namespace std;
int a[MAXN],now,n,maxn;
inline int Get(int h)
{
    int ans=abs(h-a[now]);
    F(n)
    {
        if(i==now)continue;
        if(h-abs(i-now)<=0)return 0x7f7f7f7f7f7f7ff;
        ans+=abs(a[i]-(h-abs(i-now)));
    }
    return ans;
}
inline int San_fen()
{
    int l=now,r=maxn*2;
    while(l+2<r)
    {
        int lmid=l+(r-l)/3;
        int rmid=r-(r-l)/3;
        if(Get(lmid)<Get(rmid))r=rmid;
        else l=lmid;
    }
    return min(Get(l),min(Get(l+1),Get(l+2)));
}
signed main()
{
    re int ans=0x7f7f7f7f7f7f7ff;
    scanf("%lld",&n);
    F(n)scanf("%lld",&a[i]),maxn=max(maxn,a[i]);
    for(now=1;now<=n;now++)
        ans=min(ans,San_fen());
    cout<<ans<<endl;
    return 0;
}

考虑优化，对于统计答案，我们分情况讨论一下

（讨论个毛线）详情见这里

主要说一下skyh的垃圾退火（雾）

模拟退火是一个特别神（kan）奇（lian）的算法。

是这样的：

根据物理学常识我们可以知道，物体内能越小越稳定。

所谓的模拟退火，就是模拟这个过程。

1.设置初始温度T₀

2.找出下一个目标位置

3.尝试用新的答案更新旧的答案

4.降温

是不是一脸蒙蔽？

详细来说：

while(T>eps)                                                          //终止边界
{
    tmp=now+(rand()*2ll-RAND_MAX)*T*0.000001;                         //温度越高，变化越大
    if(T<1.0)tmp=max(tmp,1ll),tmp=min(tmp,n);                         //当温度小于一定程度的时候，让下一个位置尽量小地变化
    else tmp=(tmp%n+n)%n+1;                                           //让下一个位置在要求的范围内
    tmpans=calc(tmp);D=-fabs(tmpans-nowans);                          //找到新的解
    if(tmpans<nowans||exp(D/T)*RAND_MAX>rand())nowans=tmpans,now=tmp; //根据概率确定答案是否改变
    if(tmpans<ans)ans=tmpans;                                         //更新最终的答案
    T*=0.975;                                                         //降温
}

根据前人的经验，这个更新的概率是exp（D/T）（D是变化量绝对值的相反数，T是当前温度）

最后附上完整代码

#include<bits/stdc++.h>
#define MAXN 100005
#define int long long 
using namespace std;
int yx[MAXN],n,now;
struct Bit{
    int tr[2][MAXN];
    void insert(int x,int val,int opt)
    {
        for(int i=x;i<=n;i+=i&-i)tr[0][i]+=val,tr[1][i]+=opt;
        return ;
    }
    pair<int,int> query(int x)
    {
        int num=0,ans=0;
        for(int i=x;i;i-=i&-i)num+=tr[1][i],ans+=tr[0][i];
        return make_pair(ans,num);
    }
}T[2];
int sa[MAXN],sb[MAXN],ap[MAXN],bp[MAXN],ans=0x7f7f7f7f7f7f7ff,maxa,a[MAXN],b[MAXN];
inline int check(int x)
{
    if(x<now||x<(n-now+1))return 0x7f7f7f7f7f7f7ff;
    int ans=abs(x-yx[now]);
    int num=upper_bound(a+1,a+n+1,x-now)-a-1;
    pair<int,int> w=T[0].query(num);
    ans+=abs(w.first-w.second*(x-now))+abs(sa[now-1]-w.first-(now-1-w.second)*(x-now));
    num=upper_bound(b+1,b+n+1,x+now)-b-1;
    w=T[1].query(num);
    ans+=abs(w.first-(now+x)*w.second)+abs(sb[n]-sb[now]-w.first-(n-now-w.second)*(now+x));
    return ans;
}
inline int san_fen()
{
    int l=1,r=maxa*2;
    while(l+2<r)
    {
        int lmid=l+(r-l)/3,
            rmid=r-(r-l)/3;
        if(check(lmid)<check(rmid))r=rmid;
        else l=lmid;
    }
    return min(check(l+1),min(check(l+2),check(l)));
}
signed main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&yx[i]);
        ap[i]=a[i]=yx[i]-i;
        bp[i]=b[i]=yx[i]+i;
        sa[i]=sa[i-1]+a[i];
        sb[i]=sb[i-1]+b[i];
        maxa=max(maxa,yx[i]);
    }
    sort(a+1,a+n+1);sort(b+1,b+n+1);
    for(int i=1;i<=n;i++)
    {
        ap[i]=lower_bound(a+1,a+n+1,ap[i])-a;
        bp[i]=lower_bound(b+1,b+n+1,bp[i])-b;
    }
    for(int i=1;i<=n;i++)T[1].insert(bp[i],yx[i]+i,1);
    for(now=1;now<=n;now++)
    {
        T[1].insert(bp[now],-(yx[now]+now),-1);
        ans=min(san_fen(),ans);
        T[0].insert(ap[now],yx[now]-now,1);
    }
    cout<<ans<<endl;
    return 0;
}

#include<bits/stdc++.h>
#define MAXN 100005
#define int long long
#define re register
using namespace std;
double eps=1e-5,T=100,D;
int mid,n,a[MAXN],b[MAXN];
inline int calc(int x)
{
    for(int i=1;i<=n;i++)b[i]=a[i]+abs(i-x);
    nth_element(b+1,b+mid,b+n+1);
    re int now=max(b[mid],max(x,n-x+1)),ans=0;
    for(int i=1;i<=n;i++)
    {
        if(now-abs(i-x)<=0)return 0x7f7f7f7f7f;
        ans+=abs(now-b[i]);
    }
    return ans;
}
signed main()
{
    srand((unsigned)time(0));
    cin>>n;
    mid=(1+n)>>1;
    for(int i=1;i<=n;i++)scanf("%lld",&a[i]);
    int ans=0x7f7f7f7f7f7f;
    int now=(1+n>>1);
    int nowans=calc(now),tmp,tmpans;
    while(T>eps)
    {
        tmp=now+(rand()*2ll-RAND_MAX)*T*0.000001;
        if(T<1.0)tmp=max(tmp,1ll),tmp=min(tmp,n);
        else tmp=(tmp%n+n)%n+1;
        tmpans=calc(tmp);D=-fabs(tmpans-nowans);
        if(tmpans<nowans||exp(D/T)*RAND_MAX>rand())nowans=tmpans,now=tmp;
        if(tmpans<ans)ans=tmpans;
        T*=0.975;
    }
    cout<<ans<<endl;
    return 0;
}

模拟退火是一个特别优秀的算法，请不要针对算法，（尽管你可以针对脸某）。