计蒜课 2019 8.28模拟赛部分题解

看见机房有大佬上周写了上面的普及信心赛于是我康了康 8月的提高组模拟赛 9月的还没开始qwq

https://www.jisuanke.com/contest/3119?view=challenges

真的有点难主要是我先打开了T2 我再次对自己的数学产生了怀疑

T1 又又又又都错题了下次重建图尽量写vector 都写邻接表变量差不多的容易搞混我这个同学变又写错了

T1 ：https://nanti.jisuanke.com/t/41086

题目大意就是一个有向图删一个点把与他直接和间接相连的点删掉然后求删掉所有点的最小最大代价；

为了避免这个环的情况我们显然是先 tarjan 求一下强连通分量然后考虑缩点显然是删掉这个强连通分量的任意一个点这个强连通分量都会被删掉

但是题目要求我们求出最大最小代价那我们在求tarjan的过程中维护每一个块的最大最小代价

那么对于最小代价显然是缩点之后入度为0的节点的代价的累和

对于最大代价我们反向建图从叶子结点往上便利然后每一个连通块的最大代价累和即可

#include<bits/stdc++.h>
using namespace std;
const int inf=1e9;
template<typename T>inline void read(T &x) {
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch)) ch=getchar();
    if(ch=='-') f=-1, ch=getchar();
    while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
    x*=f;
}
const int N=250000;
int n,m,x,y,cnt=0,ans1,ans2,num,tot,tc,top;
int in1[N],in2[N],Stack[N],minn[N],cost[N],maxx[N],dfn[N],low[N],lin[N],linc[N],ins[N],belong[N];
struct gg {
    int y,next;
}a[N],e[N];
inline void add(int x,int y) {
    a[++tot].y=y;
    a[tot].next=lin[x];
    lin[x]=tot;
}
inline void add_c2(int x,int y) {
    e[++tc].y=y;
    e[tc].next=linc[x];
    linc[x]=tc;
}
inline void tarjan(int x) {
    dfn[x]=low[x]=++num;
    Stack[++top]=x; ins[x]=1;
    for(int i=lin[x];i;i=a[i].next) {
        int y=a[i].y;
        if(!dfn[y]) {
            tarjan(y);
            low[x]=min(low[x],low[y]);
        }
        else if(ins[y]) 
            low[x]=min(low[x],dfn[y]);
    }
    if(dfn[x]==low[x]) {
        ++cnt;
        int k;
        do {
            k=Stack[top--];
            ins[k]=0;
            belong[k]=cnt;
            minn[cnt]=min(minn[cnt],cost[k]);
            maxx[cnt]=max(maxx[cnt],cost[k]);
        }while(x!=k);
    }
}
inline void topsort() {
    queue<int>q;
    for(int i=1;i<=cnt;i++) if(!in2[i]) q.push(i);
    while(q.size()) {
        int x=q.front();ans2+=maxx[x]; q.pop();
        for(int i=linc[x];i;i=e[i].next) {
            int y=e[i].y;
            in2[y]--;
            if(!in2[y]) q.push(y);
        }
    }
}
int main() {
    //freopen("1.in.cpp","r",stdin);
    read(n); read(m);
    for(int i=1;i<=n;i++) read(cost[i]),minn[i]=inf,maxx[i]=-inf;
    for(int i=1;i<=m;i++) {
        read(x); read(y);
        add(x,y);
    } 
    for(int i=1;i<=n;i++) {
        if(!dfn[i]) tarjan(i);
    }
    for(int i=1;i<=n;i++) {
        //cout<<maxx[i]<<endl;
        for(int j=lin[i];j;j=a[j].next) {
            int y=a[j].y;
            if(belong[i]!=belong[y]) {
                //add_c(belong[i],belong[y]);没必要建图了; 
                add_c2(belong[y],belong[i]);
                in1[belong[y]]++;
                in2[belong[i]]++;
            }
        }
    }
    ans1=ans2=0;
    for(int i=1;i<=cnt;i++) 
        if(!in1[i]) ans1+=minn[i];
    topsort();
    printf("%d %d\n",ans1,ans2);
    return 0;
}

T2 恶心数学题？？？原来只做过一个简化版的qwq 模拟赛当时考了然后暴毙了；

那个模拟赛我也没有写题解那我在这里总结一下好吧题目大意：

从（0,0）这个点不跨过 y=x 和 y=x-(n-m）到达（n,m）的方案数保证 n>=2m

显然需要用不考虑跨过任何一条直线的方案数-跨过某一条直线的方案数*2+跨过两条的方案数；

总的方案数 $\tbinom{n+m}{m}$

然后考虑跨过某一条直线的方案数 $\tbinom{n+m}{m-1}$

因为题目保证n>=2m 所以跨过第二条直线的时候就没有机会跨过第一个了qwq 所以一定是先跨过第一条线在跨过第二条线

用和卡特兰数类似的方法也能求出来方案数 $\tbinom{n+m}{m}$-$\tbinom{n+m}{m-1}$*2+$\tbinom{n+m}{m-2}$

这个T2 就比较恶心了目标就是求从

$$\tbinom{n+m}{m}$ 然后考虑一定经过p的方案数那么我们先从（0，0$

$方案数为$\tbinom{n+m}{m}$-$\tbinom{a+b}{b}$*$\tbinom{m+n-a-b}{n-a}$$

$$\tbinom{H+W-2}{H-1}$ 如果我们求出来从左上到右下（和上面坐标设的不一样，但是思路是一样的明白即可）至少经过了一个黑色格子的方案数$

$$f[i]=\tbinom{x_i-1+y_i-1}{x_i-1} - \sum_{j=0}^{i-1}\ f[j]\times \tbinom{x_i-x_j+y_i-y_j}{x_i-x_j} x_j \le x_i, y_j \le y_i$$

#include<bits/stdc++.h>
using namespace std;
#define x first
#define y second
template<typename T>inline void read(T &x) {
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch))     {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
} 
const int p=1000000007;
typedef long long ll;
const int N=200010;
int H,W,T,f[2200];
ll jc[N],jcinv[N];
pair<int,int>a[2200];
//f[i]表示 从左上角 走到排序后的第i个黑格子 并且中途不经过其他黑格子 的方案数  
inline int C(int n,int m) {
    return jc[n]*jcinv[m]%p*jcinv[n-m]%p;
}
inline ll power(ll a,int b) {
    ll res=1;
    while(b) {
        if(b&1) res=res*a%p;
        a=a*a%p;
        b>>=1;
    }
    return res;
}
int main() {
    //freopen("1..cpp","r",stdin);
    jc[0]=1;jcinv[0]=1;
    for(int i=1;i<=200000;i++) {
        jc[i]=jc[i-1]*i%p;
        jcinv[i]=power(jc[i],p-2);
    } 
    read(H); read(W); read(T);
    for(int i=1;i<=T;i++) {
        read(a[i].x); read(a[i].y);
    } 
    sort(a+1,a+T+1);
    a[T+1].x=H,a[T+1].y=W;
    for(int i=1;i<=T+1;i++) {
        f[i]=C(a[i].x+a[i].y-2,a[i].x-1);
        for(int j=1;j<i;j++) {
            if(a[j].x>a[i].x||a[j].y>a[i].y) continue;
            f[i]=(f[i]-(ll)f[j]*(C(a[i].x+a[i].y-a[j].x-a[j].y,a[i].x-a[j].x)))%p;
        }
    }
    cout<<(f[T+1]+p)%p<<endl;
    return 0;
}

好了我们又回到这个题目了qwq 具体怎么做呢不如大力分类讨论一下先毕竟我先看到T2 然后想到要分类讨论而且分类的情况较多当时弃疗不过如果真的分类讨论也不是很麻烦qwq

对于a，b>n 或者 a，b< -m 显然发现的是这两条直线对答案是没有影响的所以类比于我们上面使用的组合数

答案为 $\tbinom{n+m}{m}$ 这样可以获得十五分

那么在考虑 n,m<1000 的部分我们考虑范围较小不妨使用动态规划解决这个问题

F_i,j 表示从（0，0）走到（i，j）不经过两条直线的方案数然后由F_i-1,j和 F_i,j-1转移过来并且判断边界

对于a ,b>0 我们考虑只会有一条直线产生贡献那么直接容斥瞎搞就好了 ans=$\tbinom{n+m}{m}$-触碰到直线的方案

触碰到直线的方案是从（0，0）到将（n，m) 关于直线对称后的点的方案数思考是为什么呢

考虑所有触碰直线的路径翻转之后必定到达同一个点并且所有到达这个点的路径都在第一次触碰直线后翻转也都恰好达到

所以直接到达翻转后的点的方案数就恰好是不合法的方案数

对于 a,b<0 方案数和上面一样这样我们已经把所有比较好拿到的分数拿到了接下来就是考虑100%的数据怎么写啦

对不起还在研究题解不过近段时间会补我又来了！！！今天下午脑子清醒写了一遍

我们已经知道了 $ANS=\tbinom{n+m}{m}-先跨过A线的-先跨过B线的$

我们这里将多次触碰视作一次触碰所以触碰A线的路线只可能是 BABABABA....或者ABABABAB.....

对于先触碰A的方案数我们可以考虑先删去以A结尾的方案数然后加上以BA结尾的方案数然后减去已ABA结尾的方案数再加上以BABA结尾的方案数以此类推

显然是（n）的那么就解决了先跨过A的方案数那么我们考虑先跨过B的我们依旧按照这样的方法做

至于这种结尾方案数我们是需要将终点进行对称的这样能保证最后一定经过A线然后将关于A对称后的点记作P 我们再做P关于B的对称点这样求出来的方案数

可以保证最后先经过B 然后经过A到达终点然后我们这样逆向思维就可以了按照刚才的思路我们就处理出来所有的方案数

这里为什么倒着思考呢为什么能保证最后的方案数是先跨过A线的呢而且一加一减是不是容斥原理的应用呢这都是我需要在思考的地方先把问题抛出在做讨论

总的来说比起模拟赛上$y=x 和 y=x-(n-m)$的方案数来说这种问题模型似乎是一种通解这次我对这种组合数的理解似乎加深了一点包括隔板法的应用

可以借鉴我为jzyz题库写的题解这种数学模型真的是让信息选手头大啊

#include<bits/stdc++.h>
using namespace std;
template<typename T>inline void read(T &x) {
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch)){if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
} 
typedef long long ll;
const int p=998244353;
const int N=12000000;
const int M=13000000;
ll jc[M],jcinv[M];
int a,b,n,m;
inline ll power(ll a,ll b) {
    ll res=1;
    while(b) {
//        cout<<"((";
        if(b&1) (res*=a)%=p;
        (a*=a)%=p;
        b>>=1;
    }
    return res;
}
inline ll C(ll n,ll m) {//计算组合数 
    return jc[n]*jcinv[m]%p*jcinv[n-m]%p;
}
inline ll calc(ll n,ll m) {
    if(n<0||m<0) return 0;
    return C(n+m,n);
}
inline ll filpA(int &x,int &y) {//关于直线A对称 
    swap(x,y);
    x-=a;
    y+=a;
}
inline ll filpB(int &x,int &y) {//关于直线B对称 
    swap(x,y);
    x-=b;
    y+=b;
} 
int main() {
//    freopen("1.in","r",stdin);
    read(n); read(m); read(a); read(b);
    jc[0]=1;
    for(int i=1;i<=N;i++) jc[i]=jc[i-1]*i%p; 
    jcinv[N]=power(jc[N],p-2);
    for(int i=N-1;i>=0;--i) jcinv[i]=jcinv[i+1]*(i+1)%p;
    ll ans=calc(n,m);
    if(a<0&&b<0) a=max(a,b);
    if(a>0&&b>0) a=min(a,b);
    int x=n,y=m;
    while(x>=0&&y>=0) {
        filpA(x,y);
        ans-=calc(x,y);
        if((a<0&&b<0)||(a>0&&b>0)) {
            printf("%lld\n",((ans%p)+p)%p);
            return 0;
        }
        filpB(x,y);
        ans+=calc(x,y);
        ans%=p;
    }
    x=n,y=m;
    while(x>=0&&y>=0) {
        filpB(x,y);
        ans-=calc(x,y);
        filpA(x,y);
        ans+=calc(x,y);
        ans%=p;
    }
    ans+=p;
    ans%=p;
    printf("%lld\n",ans);
    return 0;
}

T3 ：一看就是个数据结构的样子

有

最后对每个集合都询问他的最长连续段的长度是多少。

连续段

输入格式

第一行两个数

接下来

输出格式

输出一行

数据范围与约定

对于

除

暴力模拟可以拿到三十分

别管时间跑不跑的过模拟就完事了我们考虑开个set 每次暴力找到这个集合的最长连续段

#include<bits/stdc++.h>
using namespace std;
template<typename T>inline void read(T &x) {
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch))     {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
} 
const int N=1200000;
set<int>S[N];
int n,m,tot,a[N];
inline int cal(int x) {
    set<int>::iterator it;
    tot=0;
    for(it=S[x].begin();it!=S[x].end();it++) 
        a[++tot]=*it;
    if(S[x].empty()) return 0;
    int bns=1,ans=1;
    for(int i=2;i<=tot;i++) {
        if(a[i]-1==a[i-1]) bns++;
        else bns=1;
        ans=max(ans,bns);
    }
    return ans;
}
int main() {
    read(n); read(m);
    for(int i=1;i<=m;i++) {
        int l,r,x;
        read(l); read(r); read(x);
        for(int i=l;i<=r;i++) S[i].insert(x); 
    }
    for(int i=1;i<=n;i++) printf("%d ",cal(i));
    return 0;
}

其实我们还有一种操作不妨将x 排序然后考虑操作的连续性对于连续断开考虑赋值然后查找区间历史最大值？？？对不起又口胡了

题解给的是扫描线的做法看不懂等下再学习吧。

posted @ 2019-09-24 13:19 Tyouchie 阅读(175) 评论(0) 编辑收藏举报

刷新页面返回顶部

计蒜课 2019 8.28模拟赛部分题解

输入格式

输出格式

数据范围与约定

公告