20190218【梦境】【玩具】【飘雪圣域】

贪心

玄学DP

树状数组

T1【梦境】

WOJ

$70$分
网络流跑二分图

#include<bits/stdc++.h>
using namespace std;
inline int read(){
	int x=0,f=1;char c=getchar();
	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
	while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
	return f==1?x:-x;
}
const int N=2004,M=8e6+2,s=4001,t=4002,inf=2e9;
struct edge{
	int v,f,nxt;
}e[M];
int first[N<<1],cnt=1,cur[N<<1];
inline void add(int u,int v,int f){
	e[++cnt].v=v;e[cnt].f=f;
	e[cnt].nxt=first[u];first[u]=cnt;
}
int dep[N<<1];
bool bfs(){
	queue<int>q;
	memset(dep,-1,sizeof(dep));
	dep[s]=1;
	q.push(s);
	while(!q.empty()){
		int x=q.front();q.pop();
		for(int i=first[x];i;i=e[i].nxt){
			int v=e[i].v;
			if(e[i].f>0&&dep[v]==-1){
				dep[v]=dep[x]+1;
				if(v==t)return 1;
				q.push(v);
			}
		}
	}
	return 0;
}
inline int dfs(int x,int fl){
	if(!fl||x==t)return fl;
	int used=0;
	for(int &i=cur[x];i;i=e[i].nxt){
		int v=e[i].v;
		if(e[i].f<=0||dep[v]!=dep[x]+1)continue;
		int w=dfs(v,min(fl,e[i].f));
		if(!w)continue;
		e[i].f-=w;e[i^1].f+=w;
		used+=w;fl-=w;
		if(!fl)return used;
	}
	if(!used)dep[x]=-1;
	return used;
}
int dinic(){
	int flow=0;
	while(bfs()){
		memcpy(cur,first,sizeof(first));
		flow+=dfs(s,inf);
	}
	return flow;
}
int l[N],r[N],a[N],n,m;
int main(){
	n=read();m=read();
	for(int i=1;i<=n;++i){
		l[i]=read();r[i]=read();
		add(s,i,1);add(i,s,0);
	}
	for(int i=1;i<=m;++i){
		a[i]=read();
		add(i+2000,t,1);add(t,i+2000,0); 
	}
	a[m+1]=inf;
	sort(a+1,a+m+2);
	for(int i=1,x,y;i<=n;++i){
		x=lower_bound(a+1,a+m+2,l[i])-a;
		y=upper_bound(a+1,a+m+2,r[i])-a;
		if(x==m+1)continue;
		for(int j=x;j<y;++j){
			add(i,j+2000,1);
			add(j+2000,i,0);
		}
	}
	printf("%d",dinic());
	return 0;
}

$100$分
按左端点从小到大排序，每到一个转折点$t$时，左端点在$t$之前的都已加入，用优先队列找到右边最近的一个右端点即是最优方案。（每次都要弹出右端点在$t$之前的，已不覆盖$t$了）

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+4;
int n,m,t[N],ans=0;
struct node{
	int l,r;
}a[N];
inline bool comp(const node &x,const node &y){
	return x.l<y.l;
}
priority_queue<int>q;
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		scanf("%d%d",&a[i].l,&a[i].r);
	for(int i=1;i<=m;i++)
		scanf("%d",&t[i]);
	sort(a+1,a+n+1,comp);
	sort(t+1,t+m+1);
	for(int i=1,j=1;i<=m;i++){
		for(;j<=n;j++)
			if(a[j].l<=t[i])q.push(-a[j].r);
			else break;
		while(!q.empty()&&-q.top()<t[i])q.pop();
		if(!q.empty()){q.pop();ans++;}
	}
	printf("%d",ans);
	return 0;
}

T2【玩具】

WOJ

期望=所有（取值*概率）之和

$30$分，枚举每次的球放在哪个球上，深搜。$O(N!)$

#include<bits/stdc++.h>
using namespace std;
inline int read(){
	int x=0,f=1;char c=getchar();
	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
	while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
	return f==1?x:-x;
}
#define ll long long
int n,mod,ans=0,cnt=0,hei[210];
inline int ksm(int x,int p){
	int ret=1;
	for(int i=0;i<=30;i++){
		if(p&(1<<i))ret=(ll)ret*x%mod;
		x=(ll)x*x%mod;
	}
	return ret;
}
inline void dfs(int num,int mx){
	if(num>n){
		cnt++;
		if(cnt>mod)cnt-=mod;
		ans+=mx;
		if(ans>mod)ans-=mod;
		return;
	}
	for(int i=1;i<num;i++){
		hei[num]=hei[i]+1;
		dfs(num+1,max(mx,hei[num]));
	}
	return;
}
int main(){
	n=read();mod=read();
	if(n==1){printf("0");return 0;}
	if(n==2){printf("1");return 0;}
	hei[2]=1;
	dfs(3,1);
	printf("%d",(ll)ans*ksm(cnt,mod-2)%mod);
	return 0;
}

$100$分
此题可以看做求$n$条边的树的深度的期望
推荐：%%XLY%%

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N=205;
int n,mod,inv[N],res[N],ans;
inline int ksm(int x,int p){
	int ret=1;
	for(int i=0;i<=30;i++){
		if(p&(1<<i))ret=(ll)ret*x%mod;
		x=(ll)x*x%mod;
	}
	return ret;
}
int dp[N][N],f[N][N],g[N][N];
inline int solve1(int x,int h);//树 
inline int solve2(int x,int h){//森林 
	if(h<0)return 0;
	if(x==0)return 1;
	if(g[x][h]!=-1)return g[x][h];
	g[x][h]=0;
	for(int i=1;i<=x;i++)
		g[x][h]=((ll)(solve1(i,h))*solve2(x-i,h)%mod*dp[x][i]%mod+g[x][h])%mod;
	return g[x][h];
}
inline int solve1(int x,int h){
	if(f[x][h]!=-1)return f[x][h];
	f[x][h]=solve2(x-1,h-1);
	return f[x][h];
}
int main(){
	scanf("%d%d",&n,&mod);
	if(n==1){printf("0");return 0;}
	inv[1]=1;
	for(int i=2;i<=200;i++)inv[i]=ksm(i,mod-2);
	memset(f,-1,sizeof(f));//
	memset(g,-1,sizeof(g));//
	dp[1][1]=f[1][1]=1;
	for(int i=2;i<=n;i++)
		for(int j=1;j<=n;j++)
			dp[i][j]=((ll)dp[i-1][j-1]*(j-1)%mod*inv[i]%mod+(ll)dp[i-1][j]*(i-j)%mod*inv[i]%mod)%mod;
	res[1]=ans=0;
	for(int i=2;i<=n;i++)res[i]=solve1(n,i);//选n个点做一棵树，深度不超过i的概率
	for(int i=2;i<=n;i++)ans=(ans+(ll)(res[i]-res[i-1]+mod)%mod*(i-1)%mod)%mod;//长度=深度-1 
	printf("%d",ans);
	return 0;
}

T3【飘雪圣域】

WOJ

$50$分很好想，直接$dfs$看有几个连通块就好了

#include<bits/stdc++.h>
using namespace std;
inline int read(){
	int x=0,f=1;char c=getchar();
	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
	while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
	return f==1?x:-x;
}
const int N=2e5+4;
struct edge{int v,f,nxt;}e[N<<1];
int first[N],cnt=0;
inline void add(int u,int v){
	e[++cnt].v=v;e[cnt].nxt=first[u];first[u]=cnt;
}
int n,q,vis[N],l,r,ans;
void dfs(int x){
	vis[x]=1;
	for(int i=first[x];i;i=e[i].nxt)
		if(!vis[e[i].v]&&e[i].v<=r&&e[i].v>=l)dfs(e[i].v);
}
int main(){
	n=read();q=read();
	for(int i=1,u,v;i<n;i++){
		u=read();v=read();
		add(u,v);add(v,u);
	}
	while(q--){
		l=read();r=read();
		memset(vis,0,sizeof(vis));ans=0;
		for(int i=l;i<=r;i++)
			if(!vis[i]){ans++;dfs(i);}
		printf("%d\n",ans);
	}
	return 0;
}

$100$分，其实也不难。
在线，发现好像没什么$logn$的算法直接求，所以就离线。
一条边有贡献，只有当它的两个端点都在$l-r$中。
所以连通块数量就是点数，减有贡献的边数。
把边强行转化成左端点小于右端点。
把边，询问按右端点从小到大排序。
依次扫描询问，把右端点在询问右端点之前的边，按全值将左端点加入树状数组。
查询$l-r$区间里有多少个左端点，即是我们要找的贡献。（右端点在左端点右边，也一定在区间中）

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+4;
struct node{
	int u,v,id;
}e[N],q[N];
inline bool comp(const node &x,const node &y){
	return x.v<y.v;
}
int n,m,ans[N],t[N];
inline void add(int x,int v){
	for(;x<=n;x+=x&-x)t[x]+=v;
}
inline int ask(int x){
	int ret=0;
	for(;x;x-=x&-x)ret+=t[x];
	return ret;
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++){
		scanf("%d%d",&e[i].u,&e[i].v);
		if(e[i].u>e[i].v)swap(e[i].u,e[i].v);
	}
	for(int i=1;i<=m;i++){
		scanf("%d%d",&q[i].u,&q[i].v);
		q[i].id=i;
	}
	sort(e+1,e+n,comp);//
	sort(q+1,q+m+1,comp);
	for(int i=1,j=1;i<=m;i++){
		for(;j<n;j++){
			if(e[j].v<=q[i].v)add(e[j].u,1);
			else break;
		}
		ans[q[i].id]=q[i].v-q[i].u+1-(ask(q[i].v)-ask(q[i].u-1));
		//u在区间中，则v一定在区间中 
	}
	for(int i=1;i<=m;i++)printf("%d\n",ans[i]);
	return 0;
}