【考后总结】6 月西安 NOI 模拟赛 1

合集 - 模拟赛考后总结(68)

1.【考后总结】4月清北营模拟赛 12023-04-182.【考后总结】4 月清北营模拟赛 22023-04-203.【考后总结】4 月清北营模拟赛 32023-04-24

4.【考后总结】6 月西安 NOI 模拟赛 12023-06-13

5.【考后总结】6 月西安 NOI 模拟赛 22023-06-186.【考后总结】6 月西安 NOI 模拟赛 32023-06-277.【考后总结】6 月西安 NOI 模拟赛 42023-06-278.【考后总结】6 月西安 NOI 模拟赛 52023-06-279.【考后总结】6 月 NOI 模拟赛 62023-06-2710.【考后总结】7 月 NOI 模拟赛 12023-07-0211.【考后总结】7 月 NOI 模拟赛 22023-07-1012.【考后总结】7 月 NOI 模拟赛 32023-07-1813.【考后总结】8 月 CSP-S 模拟赛 12023-08-0314.【考后总结】8 月 CSP-S 模拟赛 22023-08-0715.【考后总结】8 月 CSP-S 模拟赛 32023-08-1016.【考后总结】8 月 CSP-S 模拟赛 42023-08-1217.【考后总结】8 月 CSP-S 模拟赛 52023-08-1418.【考后总结】8 月 CSP-S 模拟赛 62023-08-1719.【考后总结】8 月 CSP-S 模拟赛 72023-08-1920.【考后总结】8 月 CSP-S 模拟赛 82023-08-2121.【考后总结】8 月 CSP-S 模拟赛 92023-08-2422.【考后总结】8 月 CSP-S 模拟赛 102023-08-2623.【考后总结】9 月 CSP-S 模拟赛 12023-09-0124.【考后总结】9 月 CSP-S 模拟赛 22023-09-1025.【考后总结】9 月 CSP-S 模拟赛 32023-09-1226.【考后总结】9 月 CSP-S 模拟赛 42023-09-1427.【考后总结】9 月 CSP-S 模拟赛 52023-09-2028.【考后总结】9 月 CSP-S 模拟赛 62023-09-2229.【考后总结】9 月 CSP-S 模拟赛 72023-09-2530.【考后总结】9 月 CSP-S 模拟赛 82023-09-2731.【考后总结】10 月 CSP-S 模拟赛 12023-10-0232.【考后总结】10 月 CSP-S 模拟赛 22023-10-0433.【考后总结】10 月 CSP-S 模拟赛 32023-10-0634.【考后总结】10 月 CSP-S 模拟赛 42023-10-0935.【考后总结】10 月 CSP-S 模拟赛 52023-10-1136.【考后总结】10 月 CSP-S 模拟赛 62023-10-1337.【考后总结】10 月 CSP-S 模拟赛 72023-10-1638.【考后总结】10 月 CSP-S 模拟赛 82023-10-1839.【考后总结】10 月 NOIP 模拟赛 12023-10-2440.【考后总结】10 月 NOIP 模拟赛 22023-10-2641.【考后总结】10 月 NOIP 模拟赛 32023-10-2842.【考后总结】10 月 NOIP 模拟赛 42023-10-3143.【考后总结】11 月 NOIP 模拟赛 12023-11-0144.【考后总结】11 月 NOIP 模拟赛 22023-11-0345.【考后总结】11 月 NOIP 模拟赛 32023-11-0646.【考后总结】11 月 NOIP 模拟赛 42023-11-0847.【考后总结】11 月 NOIP 模拟赛 52023-11-1048.【考后总结】11 月 NOIP 模拟赛 62023-11-1349.【考后总结】11 月 NOIP 模拟赛 72023-11-1550.【考后总结】12 月北京省选模拟赛 12023-12-1151.【考后总结】12 月北京省选模拟赛 22023-12-1852.【考后总结】12 月 NFLS 省选模拟赛 12023-12-2553.【考后总结】12 月 NFLS 省选模拟赛 22023-12-2954.【考后总结】1 月 NFLS 省选模拟赛 12024-01-0155.【考后总结】1 月 NFLS 省选模拟赛 22024-01-0556.【考后总结】1 月 NFLS 省选模拟赛 32024-01-0857.【考后总结】1 月 NFLS 省选模拟赛 42024-01-1258.【考后总结】1 月 NFLS 省选模拟赛 52024-01-1559.【考后总结】1 月 NFLS 省选模拟赛 62024-01-1960.【考后总结】1 月 NFLS 省选模拟赛 72024-01-2261.【考后总结】1 月 NFLS 省选模拟赛 82024-01-3062.【考后总结】2 月 NFLS 省选模拟赛 12024-02-0163.【考后总结】2 月 NFLS 省选模拟赛 22024-02-0364.【考后总结】2 月 NFLS 省选模拟赛 32024-02-0565.【考后总结】2 月 NFLS 省选模拟赛 42024-02-1666.【考后总结】2 月 NFLS 省选模拟赛 52024-02-2067.【考后总结】2 月 NFLS 省选模拟赛 62024-02-2268.【考后总结】2 月 NFLS 省选模拟赛 72024-02-26

收起

6.11 冲刺国赛模拟 16#

T3 多边形#

原题：CodeForces-1290F Making Shapes *3500

凸多边形说明合法方案中同一种向量必须连续且多种顺序只算一个，因此直接计算各个向量选择的个数。

设第 $i$ 个向量选了 $c_i$ 个，按照两个方向的正负分，可以写作：

$$\sum_{x_i>0} c_ix_i=-\sum_{x_i<0} c_ix_i\le m$$

$y$ 类似。

于是相当于构造出的方案要满足四个数都 $\le m$，可以数位 DP，按位枚举 $c$，在每一位上枚举的复杂度是 $O(2^n)$，注意到这里是有 $|x|,|y|\le \omega=4$ 的，因此可能有进位，只能从低位到高位，设 $f(i,px,py,nx,ny,limx,limy)$ 表示枚举到 $2^i$ 位，当前在 $2^i$ 位的值分别为 $px,py,nx,ny$，当前 $x,y$ 是否卡上界（$\le m$ 的条件）状态数是 $O((n\omega)^42^n\log m)$，这也是复杂度。

(赛时的想法是找互质的然后按照相似来求，和正解偏差很大，数位 DP 可以这样使用也蛮高级的）

点击查看代码

int n,m;
int x[maxn],y[maxn];
int f[maxlog][maxw][maxw][maxw][maxw][2][2];
bool vis[maxlog][maxw][maxw][maxw][maxw][2][2];
int dfs(int now,int x1,int x2,int y1,int y2,bool limx,bool limy){
	if(now==30) return !x1&&!x2&&!y1&&!y2&&limx&&limy;
	if(vis[now][x1][x2][y1][y2][limx][limy]) return f[now][x1][x2][y1][y2][limx][limy];
	vis[now][x1][x2][y1][y2][limx][limy]=true;
	int res=0;
	for(int s=0;s<(1<<n);++s){
		int tmpx1=x1,tmpx2=x2,tmpy1=y1,tmpy2=y2;
		for(int i=1;i<=n;++i){
			if(s&(1<<i-1)){
				if(x[i]>0) tmpx1+=x[i];
				else tmpx2-=x[i];
				if(y[i]>0) tmpy1+=y[i];
				else tmpy2-=y[i];
			}
		}
		if((tmpx1^tmpx2)&1||(tmpy1^tmpy2)&1) continue;
		bool chkm=(m>>now)&1,chkx=tmpx1&1,chky=tmpy1&1;
		res=(res+dfs(now+1,tmpx1/2,tmpx2/2,tmpy1/2,tmpy2/2,chkm?(!chkx||limx):(!chkx&&limx),chkm?(!chky||limy):(!chky&&limy)))%mod;
	}
	return f[now][x1][x2][y1][y2][limx][limy]=res;
}	
int ans;
int main(){
	freopen("polygon.in","r",stdin);
	freopen("polygon.out","w",stdout);
	n=read(),m=read();
	for(int i=1;i<=n;++i){
		x[i]=read(),y[i]=read();
	}
	ans=(dfs(0,0,0,0,0,true,true)-1+mod)%mod;
	printf("%d\n",ans);
	return 0;
}

6.12 冲刺国赛模拟 17#

T1 掌分治#

树上操作很经典，考虑枚举点对 $(u,v)$ 计算删除 $u$ 时 $(u,v)$ 连通的概率，求和就是答案的期望，在树上这个概率就是 $\dfrac{1}{\mathrm{dist}(u,v)}$。

放在一个环上，设 $u\to v$ 两条路径的点数分别是 $a,b$，那么只需要保证其中一条没被删除就行了，同时都没被删除需要容斥一下，答案就是 $\dfrac{1}{a}+\dfrac{1}{b}-\dfrac{1}{a+b-1}$，这里考场上想的是枚举这些点中 $u$ 删的时刻再累加，就不太好拓展了。

放在仙人掌上，先建出圆方树，考虑多个环和链结合起来的答案容斥部分并非简单的相乘，考虑固定前面走法不变，长度为 $l$，增加一个环，此时产生影响是 $\dfrac{1}{l+a}+\dfrac{1}{l+b}-\dfrac{1}{l+a+b-1}$，因此增加一个环后这些分母增加，而分母一定在 $[1,n]$ 内，考虑 DP 系数，转移类似背包。由于合并多个环可能相交部分点被算两次，所以钦定当前的环长度不算方点父亲，最终平移一位就行。

做 $n$ 次不同位置出发，复杂度 $O(n^3)$。

点击查看代码

int n,m;
int inv[maxn];
struct edge{
    int to,nxt;
}e[maxn<<2];
int head[maxn],cnt;
inline void add_edge(int u,int v){
    e[++cnt].to=v,e[cnt].nxt=head[u],head[u]=cnt;
    e[++cnt].to=u,e[cnt].nxt=head[v],head[v]=cnt;
}
int dfn[maxn],low[maxn],dfncnt;
int st[maxn],top;
int tot;
vector<int> E[maxn<<1];
unordered_map<int,int> mp[maxn];
void Tarjan(int u){
    dfn[u]=++dfncnt,low[u]=dfn[u];
    st[++top]=u;
    for(int i=head[u];i;i=e[i].nxt){
        int v=e[i].to;
        if(!dfn[v]){
            Tarjan(v);
            low[u]=min(low[u],low[v]);
            if(low[v]>=dfn[u]){
                ++tot;
                int id=0;
                while(st[top]!=v){
                    E[st[top]].push_back(tot),E[tot].push_back(st[top]);
                    mp[tot-n][st[top]]=++id;
                    --top;
                }
                E[v].push_back(tot),E[tot].push_back(v);
                mp[tot-n][v]=++id;
                --top;
                E[u].push_back(tot),E[tot].push_back(u);
                mp[tot-n][u]=++id;
            }
        }
        else low[u]=min(low[u],dfn[v]);
    }
}
int f[maxn][maxn];
void dfs(int u,int fa){
    if(u<=n){
        f[u][0]=1;
        for(int v:E[u]){
            if(v==fa) continue;
            dfs(v,u);
        }
    }
    else{
        if((int)E[u].size()==2){
            for(int v:E[u]){
                if(v==fa) continue;
                dfs(v,u);
                for(int i=0;i+1<n;++i) f[fa][i+1]=(f[fa][i+1]+f[v][i])%mod;
            }
        }
        else{
            int id=mp[u-n][fa];
            int now=0;
            for(int v:E[u]){
                ++now;
                if(v==fa) continue;
                dfs(v,u);
                int k1=abs(now-id),k2=(int)E[u].size()-k1;
                for(int i=0;i+k1<n;++i) f[fa][i+k1]=(f[fa][i+k1]+f[v][i])%mod;
                for(int i=0;i+k2<n;++i) f[fa][i+k2]=(f[fa][i+k2]+f[v][i])%mod;
                for(int i=0;i+k1+k2-1<n;++i) f[fa][i+k1+k2-1]=(f[fa][i+k1+k2-1]-f[v][i]+mod)%mod;
            }
        }
    }
}
int ans;
int main(){
    freopen("cactus.in","r",stdin);
    freopen("cactus.out","w",stdout);
    n=read(),m=read();
    inv[1]=1;
    for(int i=2;i<=n;++i) inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;
    for(int i=1;i<=m;++i){
        int u=read(),v=read();
        add_edge(u,v);
    }
    tot=n;
    Tarjan(1);
    for(int i=1;i<=n;++i){
        memset(f,0,sizeof(f));
        dfs(i,0);
        for(int j=0;j<n;++j) ans=(ans+1ll*f[i][j]*inv[j+1]%mod+mod)%mod;
    }
    printf("%d\n",ans);
    return 0;
}

T3 下大雨#

原题：洛谷-P6256 ICPC 2019 WF Directing Rainfall

由于存在一些遮挡关系，雨从一个位置下落是有先后顺序的，满足拓扑关系，拓扑的条件类似扫描线，从左到右扫描，对于两个 $x$ 坐标上有交的线段，将左端点的较大值作为参考，比较线段上下关系，这样每次找枚举左端点上下连边即可。

这样找到一个拓扑关系，我们可以模拟这个下落的过程，设 $f_i$ 表示雨从空中落下最终落在 $(i,0)$ 的最小操作次数，从上到下枚举线段，对于一个 $x$ 坐标线段 $[l,r]$，如果左低右高，那么首先从 $i$ 位置落下的雨可以选择落到 $[l,i]$，因此是 $f$ 值在 $[l,r]$ 取后缀最小值，而在 $[l+1,r]$ 位置直接落下需要操作一次，因此再区间加 $1$，这个操作并不好执行。

考虑到操作都是区间，设 $g_i=f_i-f_{i-1}$，那么第二个操作就是单点了，而第一个操作实际上就是在 $i-1$ 与 $i$ 都在 $[l,r]$ 内的 $g$ 会发生改变，以后缀最小值为例，所有 $g_i<0$ 的位置都应该变为 $0$，但同时也会对后面造成影响。

使用 set 维护 $g_i\neq 0$ 的位置，如果 $g_i<0$ 则向前找 $g_j>0$ 的位置与 $g_i$ 抵消，直到 $g_i=0$ 或超过了取最小值的范围，即 $g_{l}$。如果此时 $g_i$ 还有剩余，这个时候因为 $g_l$ 及更前不能取最小值，可以把剩下的数全减在 $g_l$ 位置。注意这个只招 $g_j>0$ 的位置实际上是简化了差分数组依次向左改变，略去了 $g_j=0$ 减小又增大本质不变的过程。

同时考虑到前后缀最小值都要维护，分别维护 $g$ 正负两个部分是比较可行的。注意取最小值和加法两个操作不能颠倒。

另外雨滴可以从非整数的位置落下且不经过任何遮挡，所以横坐标扩大一倍即可。

复杂度考虑势能分析，每次操作使 $g$ 的绝对值增加 $2$，而每次取 $\min$ 时将两个 set 维护的信息抵消，相当于绝对值减小且至少减小 $2$，因此操作次数是 $O(n)$，算上查询前驱后继的复杂度是 $O(n\log n)$。

点击查看代码

int n,L,R;
struct Segment{
    int id,x1,y1,x2,y2;
    Segment()=default;
    Segment(int id_,int x1_,int y1_,int x2_,int y2_):id(id_),x1(x1_),y1(y1_),x2(x2_),y2(y2_){}
    bool operator<(const Segment& rhs)const{
        if(x1<rhs.x1) return 1ll*(y2-y1)*(rhs.x1-x1)+1ll*y1*(x2-x1)<1ll*rhs.y1*(x2-x1);
        else return 1ll*y1*(rhs.x2-rhs.x1)<1ll*(rhs.y2-rhs.y1)*(x1-rhs.x1)+1ll*rhs.y1*(rhs.x2-rhs.x1);
    }
}Seg[maxn];
struct Data{
    int id,val;
    Data()=default;
    Data(int id_,int val_):id(id_),val(val_){}
    bool operator<(const Data& rhs)const{
        return val>rhs.val;
    }
};
set<Segment> S;
priority_queue<Data> Q;
vector<int> E[maxn];
int deg[maxn];
queue<int> q;
multiset<pii> Sp,Sn;
int main(){
    freopen("rain.in","r",stdin);
    freopen("rain.out","w",stdout);
    L=read()*2,R=read()*2,n=read();
    for(int i=1;i<=n;++i){
        int x1=read()*2,y1=read(),x2=read()*2,y2=read();
        if(x1>x2) swap(x1,x2),swap(y1,y2);
        Seg[i]=Segment(i,x1,y1,x2,y2);
    }
    sort(Seg+1,Seg+n+1,[&](Segment A,Segment B){
        return A.x1<B.x1;
    });
    for(int i=1;i<=n;++i) Seg[i].id=i;
    for(int i=1;i<=n;++i){
        while(!Q.empty()&&Q.top().val<Seg[i].x1){
            S.erase(Seg[Q.top().id]);
            Q.pop();
        }
        auto it=S.lower_bound(Seg[i]);
        if(it!=S.end()){
            E[(*it).id].push_back(i);
            ++deg[i];
        }
        if(it!=S.begin()){
            --it;
            E[i].push_back((*it).id);
            ++deg[(*it).id];
        }
        S.insert(Seg[i]);
        Q.push(Data(i,Seg[i].x2));
    }
    for(int i=1;i<=n;++i){
        if(!deg[i]) q.push(i);
    }
    Sp.insert(mp(R+1,inf));
    Sn.insert(mp(L,inf));
    while(!q.empty()){
        int u=q.front();
        q.pop();
        if(Seg[u].y1<Seg[u].y2){
            auto it1=Sn.lower_bound(mp(Seg[u].x2+1,-inf));
            if(it1!=Sn.begin()){
                --it1;
                while((*it1).fir>=Seg[u].x1+1){
                    int val=(*it1).sec;
                    auto it2=Sp.lower_bound(mp((*it1).fir+1,-inf));
                    if(it2!=Sp.begin()){
                        --it2;
                        while(val&&(*it2).fir>=Seg[u].x1){
                            if((*it2).sec>val){
                                Sp.insert(mp((*it2).fir,(*it2).sec-val));
                                Sp.erase(it2);
                                val=0;
                                break;
                            }
                            else{
                                val-=(*it2).sec;
                                auto tmp=it2;
                                if(it2!=Sp.begin()){
                                    --it2;
                                    Sp.erase(tmp);
                                }
                                else{
                                    Sp.erase(tmp);
                                    break;
                                }
                            }
                        }
                    }   
                    if(val) Sn.insert(mp(Seg[u].x1,val));
                    auto tmp=it1;
                    if(it1!=Sn.begin()){
                        --it1;
                        Sn.erase(tmp);
                    }
                    else{
                        Sn.erase(tmp);
                        break;
                    }
                }
            }
            Sp.insert(mp(Seg[u].x1+1,1));
            Sn.insert(mp(Seg[u].x2+1,1));
        }
        else{
            auto it1=Sp.lower_bound(mp(Seg[u].x1,-inf));
            while(it1!=Sp.end()&&(*it1).fir<=Seg[u].x2){
                int val=(*it1).sec;
                auto it2=Sn.lower_bound(mp((*it1).fir,-inf));
                while(it2!=Sn.end()&&val&&(*it2).fir<=Seg[u].x2+1){
                    if((*it2).sec>val){
                        Sn.insert(mp((*it2).fir,(*it2).sec-val));
                        Sn.erase(*it2);
                        val=0;
                        break;
                    }
                    else{
                        val-=(*it2).sec;
                        auto tmp=it2;
                        ++it2;
                        Sn.erase(tmp);
                        if(it2==Sn.end()) break;
                    }
                }
                if(val) Sp.insert(mp(Seg[u].x2+1,val));
                auto tmp=it1;
                ++it1;
                Sp.erase(tmp);
            }
            Sp.insert(mp(Seg[u].x1,1));
            Sn.insert(mp(Seg[u].x2,1));
        }
        for(int v:E[u]){
            --deg[v];
            if(!deg[v]) q.push(v);
        }
    }
    for(auto it=Sn.begin();it!=Sn.end();++it){
        Sp.insert(mp((*it).fir,-(*it).sec));
    }
    int ans=inf,sum=inf,now=-inf;
    Sp.insert(mp(L,0));
    for(auto it=Sp.begin();it!=Sp.end();++it){
        if((*it).fir!=now&&now>=L&&now<=R) ans=min(ans,sum);
        now=(*it).fir,sum+=(*it).sec;
    }
    printf("%d\n",ans);
    return 0;
}

6.13 冲刺国赛模拟 18#

3.29 省选模拟（沈子舜）