暑期集训第十五天（7-6）题解及总结

小总结:

今天上午又轮到老姚出题了,老姚这次出题莫名多了一道数论(说好的不出数论呢???),还有就是一如既往的dp多,四道题里面有两道dp题目......

明天高三学长要高考了,祝愿他们能取得的一个好成绩吧(稍微带一下我呗~)

T1:精灵魔法

看到这一道题乍一看是没有什么思路的,但是详细一想,我们可以对编号进行离散化,记录一下一个人前面还有多少人编号比他大,之后以速度为基准进行排序,再数出一个点前面有多少人编号比他大,减一下就好了,原因是两个点的互换在一个点超过一个点和一个点被超过是等价的,我们只统计其中一种就可以了,这里统计的是一个点超过的点的个数,于是我们考虑从大到小枚举,把前面的点记录一下他比几个点大,之后轮到某个点之后看一下前面有几个点比他大,这样就可以统计答案了,这是什么,是区间修改,单点查询,于是选择用线段树进行维护,注意在对速度进行排序的时候要特别处理一下相等的情况,不然会100->70.

其实关于这道题的主流做法是单点修改,区间查询(和我正好相反),还可以用归并排序求逆序对,我都试着打了一下,这里就不放代码了,退一下老师的博客:https://www.cnblogs.com/hbhszxyb/p/13253975.html

#include<bits/stdc++.h>
#define int long long
#define debug printf("-debug-
")
#define lson (t<<1)
#define rson (t<<1|1)
#define mid ((l+r)>>1)
using namespace std;
const int N=1e6+10;
struct Tree{
    int w,lazy,siz;
}tree[N];
void pushup(int t){
    tree[t].w=tree[lson].w+tree[rson].w;
}
void build(int t,int l,int r){
    tree[t].siz=r-l+1;
    if(l==r) return;
    build(lson,l,mid);build(rson,mid+1,r);
    pushup(t);
}
void pushdown(int t){
    tree[lson].w+=tree[t].lazy;
    tree[lson].lazy+=tree[t].lazy;
    tree[rson].w+=tree[t].lazy;
    tree[rson].lazy+=tree[t].lazy;
    tree[t].lazy=0;
}
void change(int t,int l,int r,int cl,int cr){
    if(cl<=l&&r<=cr){
        tree[t].w+=tree[t].siz;
        tree[t].lazy++;
        return;
    }
    pushdown(t);
    if(cr<=mid) change(lson,l,mid,cl,cr);
    else if(cl>mid) change(rson,mid+1,r,cl,cr);
    else{
        change(lson,l,mid,cl,cr);change(rson,mid+1,r,cl,cr);
    }
    pushup(t);
}
int query(int t,int l,int r,int pos){
    if(l==r){
        return tree[t].w;
    }
    pushdown(t);
    if(pos<=mid) return query(lson,l,mid,pos);
    else return query(rson,mid+1,r,pos);
}
int ans=0,cnt=0;
struct Node{
    int num,v;
}a[N];
bool cmp1(Node a,Node b){
    return a.num<b.num;
}
bool cmp2(Node a,Node b){
    if(a.v==b.v) return a.num<b.num;
    return a.v<b.v;
}
signed main(){
    int n;
    scanf("%lld",&n);
    build(1,1,n);
    for(int i=1;i<=n;++i){
        scanf("%lld",&a[i].num);
    }
    for(int i=1;i<=n;++i) scanf("%lld",&a[i].v);
    sort(a+1,a+n+1,cmp1);
    for(int i=1;i<=n;++i) a[i].num=++cnt;//离散化
    sort(a+1,a+n+1,cmp2);
    for(int i=n;i>=1;--i){
        int cnt1=n-a[i].num;
        int cnt2=query(1,1,n,a[i].num);
        if(cnt1-cnt2>0) ans+=cnt1-cnt2;
        if(a[i].num>1) change(1,1,n,1,a[i].num-1);
    }
    printf("%lld
",ans);
    return 0;
}

T2:最小环

 这道题的题目是误导人的......我们从数据范围之中可以得到n^3的最小环求发是一定不行的,并且你求出的最小环不一定包含一号节点。

这道题目考虑我们如果想要用最短路来跑，要避免的情况就是从1节点出去的方向再次回到1号节点，于是我们可以考虑把从1号节点出去的方向的路线断掉，之后再从被隔离的节点跑一遍最短路，对1号节点此时的距离进行取最小值就可以了。

这到题奇葩的dijksta会T掉，Spfa反而可以，但是我考试的时候吸氧水过了。

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
struct Node{
    int next,to,dis;
}edge[N];
int Head[N],tot=1;
void Add(int x,int y,int z){
    edge[++tot].to=y;
    edge[tot].dis=z;
    edge[tot].next=Head[x];
    Head[x]=tot;
}
struct Edge{
    int num,dis;
    Edge(int x,int y){
        num=x;dis=y;
    }
    bool operator < (const Edge &a)const{
        return a.dis<dis;
    }
};
priority_queue<Edge>q;
int dis[N],vis[N],ans=0x3f3f3f3f;
void dijkstra(int x){
    memset(dis,0x3f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[x]=0;q.push(Edge(x,0));
    while(!q.empty()){
        int u=q.top().num;q.pop();
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=Head[u];i;i=edge[i].next){
            int v=edge[i].to;
            if(dis[v]>dis[u]+edge[i].dis){
                dis[v]=dis[u]+edge[i].dis;
                q.push(Edge(v,dis[v]));
            }
        }
    }
}
void Init(){
    memset(edge,0,sizeof(edge));
    memset(Head,0,sizeof(Head));
    tot=1;ans=0x3f3f3f3f;
}
void Solve(){
    Init();
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;++i){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        Add(x,y,z);Add(y,x,z);
    }
    for(int i=Head[1];i;i=edge[i].next){
        int v=edge[i].to;
        int cnt=edge[i].dis;
        //printf("%d %d %d
",v,edge[i].dis,edge[i^1].dis);
        edge[i^1].dis=0x3f3f3f3f;
        dijkstra(v);
        ans=min(ans,dis[1]+edge[i].dis);
        edge[i^1].dis=cnt;
    }
    if(ans!=0x3f3f3f3f) printf("%d
",ans);
    else printf("-1
");
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--) Solve();
    return 0;
}

T3：LGTB 与序列

 

 这道题一看是数论当时直接就放弃去看第四道题了，其实这道题和数论的关系并没有那么大，主要还是一道dp题目。

我们可以考虑a_i<=30,其实如果我们去的数字大于58了,就不如直接放1,反正1和任何数字互质,放多少个1都可以,另外,在2~58之内一共有16个质数,于是我们可以吧1~58里面的所有数字进行质因子分解,之后我们可以借助状压dp的思路来记录那些质因子已经被选过了,对于输入的数字我们进行降序排序,用16个质因子里面组成尽可能大的数字来应对a数组之中大的数字,之后就是一道很普通的状压dp题目了,和排列prem就没有什么不同了.

 

#include <bits/stdc++.h>
const int maxn=105,maxp=17,Inf=0x3f3f3f3f;
int prime[] = {0,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53}; 
int n,a[maxn];
int dp[maxp][1<<maxp];
int _prime[maxn];
bool cmp(int a,int b){
    return a>b;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    std::sort(a+1,a+n+1,cmp);
    memset(_prime,0,sizeof(_prime));
    for(int i=1;i<=58;i++)
        for(int j=1;j<=16;j++)
            if(i<prime[j]) break;
            else if(i%prime[j]==0)
                _prime[i]|=(1<<j-1);
    memset(dp,0x3f,sizeof(dp));
    dp[0][0]=0;
    for(int i=1;i<=std::min(n,16);i++)
        for(int j=0;j<(1<<16);j++) 
            for(int k=1;k<=58;k++)
                if(!(_prime[k]&j)){
                    int s=j|_prime[k];
                    dp[i][s]=std::min(dp[i][s],dp[i-1][j]+abs(a[i]-k));
                }
    int ans=Inf;
    for(int j=0;j<(1<<16);j++)
        ans=std::min(ans,dp[std::min(n,16)][j]);
    if(n>16)
        for(int i=17;i<=n;i++)
            ans+=abs(a[i]-1);
    printf("%d
",ans);
    return 0;
}

 

T4:步步为零

 这道题一看就能看出是一道dp的题目,因为它的状态和转移十分明显,但是着手去写的时候你会发现总体思路越写越乱,于是最后我只打了一个爆搜水了20pts......

这道题的dp数组与众不同的是它的数组是bool型的,dp[i][j][k]表示从起点走到(i,j)时得到的数字能否组成k这个数字

到时间了....明天要高考,我们要提前回去,未完待续中........