小米 OJ 编程比赛 12 月常规赛题解

最新推荐文章于 2019-05-01 13:23:10 发布

原创最新推荐文章于 2019-05-01 13:23:10 发布 · 917 阅读

3 ·

CC 4.0 BY-SA版权

比赛----其他比赛题解专栏收录该内容

17 篇文章

订阅专栏

本文精选了三道算法竞赛题目并提供了详细的解题思路及代码实现，包括基础数论问题、nim博弈策略以及网络流应用的复杂场景。通过实例解析，深入浅出地介绍了sg函数在博弈论中的应用，以及如何将复杂问题转化为图论和网络流问题求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数学队友一退役，整个实验室数论就只会gcd了...

小米兔跳格子

思路：签到题。

#include<bits/stdc++.h>
using namespace std;
int a[100],cnt=0;
int main()
{
	while(~scanf("%d",&a[1]))
	{
		int ans=1,x;
		cnt=1;
		while(~scanf("%d",&x))
		a[++cnt]=x;
		for(int i=1;i<=cnt;i++)
		{
			
			if(ans<i)break;
			if(a[i]>0)
			ans=max(ans,i+a[i]);
		}
		if(ans<cnt)puts("false");
		else puts("true");		
	}
}

数数字游戏

思路：nim博弈的一种，sg函数的入门题（学了半个小时学会了，还是要向全能型选手发展才行），学习sg函数推荐：博弈论 SG函数

#include<bits/stdc++.h>
using namespace std;
const int N=1e4+10; 
int vis[1005],d[30],cnt;
int sg[N];
int main()
{
	d[1]=1,d[2]=2;
	vis[1]=vis[2]=1;
	for(int i=3;;i++)
	{
		d[i]=d[i-1]+d[i-2];
		if(d[i]>10000)break;
		cnt=i;
	}
	for(int i=1;i<N;i++)
	{
		memset(vis,0,sizeof(vis));
		for(int j=1;j<=cnt&&d[j]<=i;j++)
		vis[sg[i-d[j]]]=1;
		for(int j=0;;j++)if(!vis[j])
		{
			sg[i]=j;
			break;
		}
	}
	int a,b;
	while(~scanf("%d%d",&a,&b))
	{
		int c=sg[a]^sg[b];
		if(c)puts("Xiaoai Win");
		else puts("Xiaobing Win");
	}
}

MMD

思路：还是这个题有意思，首先每条线段的基本优美度是固定的，我要设计一种走法，使得额外的优美度最大，既然要走，不妨把每个线段看成点，每两条相交线段连成一条权值为 (vi+vj)*((i+j)/2)的有向边，这样就转化成图论问题了，也就是说，我需要在图上走，每个点只能走一次，使得路径上遇到的边权和最大，等等，这不有点像网络流吗，每个点走一次，那么也就是源点连上的每个点，流量都为1，费用为0，把每个点拆成点 i 和点 i+n，且都连接汇点，流量都为1，费用为0，把每条有向边设为 i-->j+n，流量为1，费用为负的边权，这样跑出来的最小费用流的相反数就是最大的优美度。

#include<bits/stdc++.h>
#define db double
using namespace std;
const int maxn=610,inf=1e9;
map<string,int>mp;
struct Edge
{
	int from,to,cap,flow,cost;
	Edge(int a,int b,int c,int d,int e)
	{
		from=a,to=b,cap=c,flow=d,cost=e;
	}
};
struct MCMF{
	int n,m,s,t;
	vector<Edge>edges;
	vector<int>G[maxn];
	int inq[maxn];
	int d[maxn];
	int p[maxn];
	int a[maxn];
	void init(int n)
	{
		this->n=n;
		for(int i=0;i<=n;i++)G[i].clear();
		edges.clear();
	}
	void add(int from,int to,int cap,int cost)
	{
		edges.push_back(Edge(from,to,cap,0,cost));
		edges.push_back(Edge(to,from,0,0,-cost));
		m=edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	bool bellman(int s,int t,int& flow,int& cost)
	{
		for(int i=0;i<=n;i++)d[i]=inf,inq[i]=0;
		d[s]=0;inq[s]=1;p[s]=0;a[s]=inf;
		queue<int>Q;
		Q.push(s);
		while(!Q.empty())
		{
			int u=Q.front();Q.pop();
			inq[u]=0;
			for(int i=0;i<G[u].size();i++)
			{
				Edge& e=edges[G[u][i]];
				if(e.cap>e.flow&&d[e.to]>d[u]+e.cost)
				{
					d[e.to]=d[u]+e.cost;
					p[e.to]=G[u][i];
					a[e.to]=min(a[u],e.cap-e.flow);
					if(!inq[e.to])
					{
						Q.push(e.to);
						inq[e.to]=1;
					}
				}
			}
		}
		if(d[t]==inf)return false;
		flow+=a[t];
		cost+=d[t]*a[t];
		int u=t;
		while(u!=s)
		{
			edges[p[u]].flow+=a[t];
			edges[p[u]^1].flow-=a[t];
			u=edges[p[u]].from;
		}
		return true;
	}
	int mincost(int s,int t)
	{
		int flow=0,cost=0;
		while(bellman(s,t,flow,cost));
		return cost;
	}
}solve;
struct point
{
	db x,y;
}p[maxn],q[maxn];
int v[maxn];
int check(point a,point b,point c,point d)
{
	if(!(min(a.x,b.x)<=max(c.x,d.x)&&min(c.y,d.y)<=max(a.y,b.y)&&min(c.x,d.x)<=max(a.x,b.x)&&min(a.y,b.y)<=max(c.y,d.y)))
	{
		return 0;
	}	
	db u,v,w,z;
	u=(c.x-a.x)*(b.y-a.y)-(b.x-a.x)*(c.y-a.y);
	v=(d.x-a.x)*(b.y-a.y)-(b.x-a.x)*(d.y-a.y);
	w=(a.x-c.x)*(d.y-c.y)-(d.x-c.x)*(a.y-c.y);
	z=(b.x-c.x)*(d.y-c.y)-(d.x-c.x)*(b.y-c.y);
	return u*v<=0&&w*z<=0;
}
int main()
{
	int n;
	while(cin>>n)
	{
		int T=2*n+1;
		solve.init(T+1);
		for(int i=1;i<=n;i++)
		{
			cin>>p[i].x>>p[i].y>>q[i].x>>q[i].y>>v[i];
			solve.add(0,i,1,-v[i]);
			solve.add(i,T,1,0);
			solve.add(i+n,T,1,0);
			for(int j=1;j<i;j++)
			if(check(p[j],q[j],p[i],q[i]))
			{
				if(v[j]>v[i])solve.add(j,i+n,1,-(v[j]+v[i])*((i+j)/2));
				if(v[j]<v[i])solve.add(i,j+n,1,-(v[j]+v[i])*((i+j)/2));
			}
		}
		printf("%d\n",-solve.mincost(0,T));
	}
}