2021.10.9

T1:a

Problem:

小 A 有一列数字，这列数字很乱，他看着很不爽。于是他打算删掉其中的一些，使得剩下的序列满足第𝑖个位置的值是𝑖的位置尽可能多。请你告诉他最多能有多少个位置满足。

Solution:

三维偏序

Code:

#include<bits/stdc++.h>
using namespace std;
int n,tot,mx,c[200005];
struct node{
    int i,a;
}a[100005];
bool cmp(const node &a,const node &b){
    if(a.i==b.i) return a.a<b.a;
    else return a.i<b.i;
}
inline int lowbit(int x){
    return x&-x;
}
inline void update(int x,int g){
    while(x<=mx){
        c[x]=max(c[x],g);
        x+=lowbit(x);
    }
}
inline int ask(int x){
    int ans=0;
    while(x){
        ans=max(ans,c[x]);
        x-=lowbit(x);
    }
    return ans;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int x;
        scanf("%d",&x);
        if(i<x) continue;
        tot++;
        a[tot].i=i-x;
        a[tot].a=x;
        mx=max(mx,x);
    }
    sort(a+1,a+1+tot,cmp);
    mx=min(mx,2*n);
    int ans=0;
    for(int i=1;i<=tot;i++){
        int d=ask(a[i].a-1)+1;
        update(a[i].a,d);
        ans=max(ans,d);
    }
    cout<<ans;
    return 0;
}

T2:b

Problem:

给定一个𝑛个点𝑚条边的无向图，每条边有边权。每次询问某一条边不能走的情况下，1到𝑛的最短路。

Code:

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=100005;
const int M=200005;
int n,m,S,T;
int last[N],nxt[M<<1],to[M<<1],ecnt=1;
int w[M<<1];
bool vis[N];
ll distS[N],distT[N];
inline void add(int u,int v,int val){
    nxt[++ecnt]=last[u];
    last[u]=ecnt;
    to[ecnt]=v;
    w[ecnt]=val;
    nxt[++ecnt]=last[v];
    last[v]=ecnt;
    to[ecnt]=u;
    w[ecnt]=val;
}
inline void Dij(int S,ll dist[]){
    memset(dist,0x3f,sizeof distS);
    memset(vis,0,sizeof vis);
    set<pair<ll,int> > q;
    q.insert(make_pair(dist[S]=0,S));
    while(!q.empty()){
        int u=q.begin()->second;
        q.erase(q.begin());
        if(vis[u]) continue;
        for(int e=last[u],v=to[e];e;v=to[e=nxt[e]]){
            if(dist[v]>dist[u]+w[e]){
                q.erase(make_pair(dist[v],v));
                q.insert(make_pair(dist[v]=dist[u]+w[e],v));
            }
        }
    }
}
bool use[N];
struct E{
    int v,id;
};
vector<E> g[N],rg[N];
bool tree_edge[M],dfned[N];
int pos[N],tot,id[N];
int f[N],pre[N];
void dfs(int u,int fa){
    dfned[u]=true;
    f[u]=fa;
    id[pos[u]=++tot]=u;
    for(int e=last[u],v=to[e];e;v=to[e=nxt[e]]){
        if(dfned[v]||v==fa) continue;
        if(distS[v]==distS[u]+w[e]){
            dfs(v,u);
            tree_edge[e>>1]=true;
            pre[v]=e>>1;
            g[u].push_back((E){v,e>>1});
        }
    }
}
bool haveT[N],ban[N];
set<pair<ll,int> > s;
int q[N],qn;
void dfs_vis(int u){
    q[++qn]=u;
    ban[u]=true;
    for(int e=0;e<g[u].size();++e){
        int v=g[u][e].v;
        if(ban[v])continue;
        dfs_vis(v);
    }
}
bool ins[M];
ll ans[M];
void solve(){
    for(int i=1;i<=m;++i){
        if(!tree_edge[i]){
            ans[i]=distS[T];
        }
    }
    haveT[T]=true;
    for(int o=tot;o>1;--o){
        int u=id[o];
        if(haveT[u]){
            haveT[f[u]]=true;
            qn=0;
            dfs_vis(u);
            for(int i=1;i<=qn;++i){
                int p=q[i];
                for(int e=last[p],v=to[e];e;v=to[e=nxt[e]]){
                    if(tree_edge[e>>1]) continue;
                    if(ban[v]){
                        if(ins[e>>1]){
                            s.erase(make_pair(distS[p]+w[e]+distT[v],e>>1));
                        }
                    }
                    else{
                        s.insert(make_pair(distT[p]+w[e]+distS[v],e>>1));
                        ins[e>>1]=true;
                    }
                }
            }
            ans[pre[u]]=s.empty()?-1:s.begin()->first;
        }
        else{
            ans[pre[u]]=distS[T];
        }
    }
}
signed main(){
    S=1;
    scanf("%d%d",&n,&m);
    T=n;
    for(int i=1;i<=m;++i){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add(u,v,w);
    }
    Dij(S,distS);
    Dij(T,distT);
    if(distS[T]>1e18){
        for(int i=1;i<=m;++i) cout<<"-1\n";
        return 0;
    }
    dfs(S,0);
    solve();
    for(int i=1;i<=m;++i) cout<<ans[i]<<"\n";
    return 0;
}

T3:c

Problem:

有一个长为𝑛的序列，𝑚次询问，每次询问一个区间内每个数字的(出现次数×数字的值)最大是多少。

Code:

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int maxn=100030;
int n,m,a[maxn],b[maxn],pos[maxn],sum[maxn];
int cnt[maxn],ans[maxn],pre,now;
struct node{
    int l,r,lpos,rpos,id;
}q[maxn];
bool cmp(node x,node y){
    if(x.lpos==y.lpos) return x.r<y.r;
    else return x.lpos<y.lpos;
}
inline void add(int id){
    int x=a[id];
    sum[x]+=b[x];
    now=max(now,sum[x]);
}
inline void del(int id){
    int x=a[id];
    sum[x]-=b[x];
}
signed main(){
    scanf("%d%d",&n,&m);
    int block=sqrt(n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        b[i]=a[i];
        pos[i]=(i-1)/block+1;
    }
    sort(b+1,b+1+n);
    int un=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=n;i++){
        a[i]=lower_bound(b+1,b+1+un,a[i])-b;
    }
    for(int i=1;i<=m;i++){
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
        q[i].lpos=pos[q[i].l];
        q[i].rpos=pos[q[i].r];
    }
    sort(q+1,q+1+m,cmp);
    int pos=0,l=0,r=1;
    for(int i=1;i<=m;i++){
        int L=q[i].l,R=q[i].r;
        if(q[i].lpos!=q[i-1].lpos){
            memset(sum,0,sizeof(sum));
            pre=now=0;
            l=pos=q[i].lpos*block+1;
            r=l-1;
        }
        if(q[i].lpos==q[i].rpos){
            int cur=0;
            for(int j=L;j<=R;j++){
                cnt[a[j]]+=b[a[j]];
                cur=max(cur,cnt[a[j]]);
            }
            ans[q[i].id]=cur;
            for(int j=L;j<=R;j++){
                cnt[a[j]]-=b[a[j]];
            }
            continue;
        }
        while(r<R) add(++r);
        pre=now;
        while(l>L) add(--l);
        ans[q[i].id]=now;
        while(l<pos) del(l++);
        now=pre;
    }
    for(int i=1;i<=m;i++){
        cout<<ans[i]<<endl;
    }
    return 0;
}