【解题报告】NOIP2013

【解题报告】NOIP2013

Day1

T1 转圈游戏

思路

我们手模发现,就是 \(x+m \times 10^k \space mod \space n\)

然后一个快速幂就没了,开 long long

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
int n,m,k,x;
long long ksm(long long a,long long b,int p)
{
	long long ans=1%p;
	for( ;b;b>>=1)
	{
		if(b&1)
		ans=(long long)ans*a%p;
		a=(long long)a*a%p; 
	}
	return ans;
}
int main()
{
	cin>>n>>m>>k>>x;
	cout<<(ksm(10,k,n)*m%n+x%n)%n<<endl;
	return 0;
}

T2 火柴排队

思路

值域树状数组

我们要使得 \(\sum (a_i-b_i)^2\) 最小

变形一下

\[\sum (a_i^2+2a_ib_i+b_i^2) \\= \sum (a_i^2+b_i^2)+\sum2a_ib_i \]

我们发现 \(\sum (a_i^2+b_i^2)\) 是一个定值,所以我们只需要让 \(\sum 2a_ib_i\) 最小就好了

如何让两个数列的 \(2a_ib_i\) 最小呢

我们可以让两个序列中的数字各自标上排名

然后如果两个数列的数字的排名相对应,我们就可以让它最小

比如说

2 3 1 4

3 2 1 4

我们只需要交换一次

再比如

1 3 4 2

1 7 2 4

我们让他们对应,也就是将第二个序列中的 7 2 4 变成 4 7 2 ,交换两次

那我们就以第一个数列为基准,对于这个数列我们就可以离散化一下,表示排名,然后建立两个数列间的类似于最长公共子序列的 \(O(n^2)\) 的做法的方法来建立一一映射的关系

值域树状数组求逆序对即可

这样就做完了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int maxn=500005;
const int mod=99999997;
int tree[maxn],rank[maxn],n;
long long ans;
struct point{
	int num,val;
}a[maxn],b[maxn];
int lowbit(int x)
{
	return x&(-x);
}
bool cmp(point q,point w)
{
	if(q.val==w.val)
	return q.num<w.num;
	return q.val<w.val;
}
void add(int x,int y)
{
	for( ;x<=n;x+=lowbit(x)) tree[x]+=y,tree[x]%=mod;
}
int ask(int x)
{
	int ans=0;
	for( ;x;x-=lowbit(x)) ans+=tree[x],ans%=mod;
	return ans;
}
int main()
{
	std::ios::sync_with_stdio(false);
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>a[i].val;
		a[i].num=i;
	}
	for(int i=1;i<=n;i++)
	{
		cin>>b[i].val;
		b[i].num=i;
	}
	sort(a+1,a+1+n,cmp);
	sort(b+1,b+1+n,cmp);
	for(int i=1;i<=n;i++)
	rank[a[i].num]=b[i].num;
	for(int i=1;i<=n;i++)
	{
		add(rank[i],1);
		ans+=(i-ask(rank[i]));
		ans%=mod;
	}
	cout<<ans<<endl;
	return 0;
}

T3 货车运输

思路

最大生成树 + LCA

我们要求的是每一条路径中最小边的最大值,这个最大值肯定会加入最大生成树,所以我们做一个最大生成树

然后,对于这棵树,我们倍增预处理每一条边到自己的 \(k\) 级祖先的答案,然后我们用倍增 \(lca\) 来合并答案

然后就没了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath> 
using namespace std; 

const int maxn=10005;
const int INF=999999999;

struct edge1{  
    int x,y,dis;
}ed1[50005]; 
struct edge2{
    int to,next,w;
}ed2[100005];
int cnt,n,m,head[maxn],deep[maxn],f[maxn],fa[maxn][21],w[maxn][21];
bool vis[maxn]; 
void add_edge(int from, int to, int w)
{
    ed2[++cnt].next=head[from];
    ed2[cnt].to=to;
    ed2[cnt].w=w;
    head[from]=cnt;
    return ;
}

bool cmp(edge1 x, edge1 y)
{
    return x.dis>y.dis; //将边权从大到小排序 
}

int find(int x)
{
    if(f[x]!=x) f[x]=find(f[x]);
    return f[x];
}

void kruskal()
{
    sort(ed1+1,ed1+m+1,cmp); 
    for(int i=1;i<=n;i++)
    f[i]=i;
    for(int i=1; i<=m; i++)
    if(find(ed1[i].x)!=find(ed1[i].y))
	{
        f[find(ed1[i].x)]=find(ed1[i].y);
        add_edge(ed1[i].x, ed1[i].y, ed1[i].dis);
        add_edge(ed1[i].y, ed1[i].x, ed1[i].dis); 
    }
    return ;
}

void dfs(int node)
{
    vis[node]=true;
    for(int i=head[node]; i; i=ed2[i].next)
	{
        int to=ed2[i].to;
        if(vis[to]) continue;
        deep[to]=deep[node]+1;
        fa[to][0]=node;
        w[to][0]=ed2[i].w;
        dfs(to);
    }
    return ;
}

int lca(int x, int y)
{
    if(find(x)!=find(y)) return -1;
    int ans=INF;
    if(deep[x]>deep[y]) swap(x,y);
    for(int i=20; i>=0; i--)
        if(deep[fa[y][i]]>=deep[x])
		{
            ans=min(ans, w[y][i]);
            y=fa[y][i];
        }
    if(x==y) return ans;
    for(int i=20; i>=0; i--)
        if(fa[x][i]!=fa[y][i])
		{
            ans=min(ans, min(w[x][i], w[y][i]));
            x=fa[x][i]; 
            y=fa[y][i];
        }
    ans=min(ans, min(w[x][0], w[y][0]));
    return ans;
}

int main()
{
    int x,y,z,q;
    cin>>n>>m;
    for(int i=1; i<=m; i++)
	{
        cin>>x>>y>>z;
        ed1[i].x=x;
        ed1[i].y=y;
        ed1[i].dis=z;
    }
    kruskal();
    for(int i=1;i<=n;i++)
        if(!vis[i])
		{
            deep[i]=1; 
            dfs(i);
            fa[i][0]=i;
            w[i][0]=INF;
        }
    for(int i=1;i<=20;i++)
        for(int j=1;j<=n;j++)
		{
            fa[j][i]=fa[fa[j][i-1]][i-1]; 
            w[j][i]=min(w[j][i-1], w[fa[j][i-1]][i-1]);
        }
    cin>>q;
    for(int i=1; i<=q; i++)
	{
		cin>>x>>y;
        cout<<lca(x,y)<<endl;
    }
    return 0;
} 

Day2

T1 积木大赛

思路

贪心

每往后走一个,想着把前面所有的填到跟他一个高度,这样就是最小填的次数

别忘了加最开始的第一堆积木的高度

#include<bits/stdc++.h>
using namespace std;
int n,a[100005];
long long ans=0;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)     
    cin>>a[i];
    for(int i=2;i<=n;i++)     
    if(a[i]>a[i-1]) 
    ans+=a[i]-a[i-1];
    cout<<ans+a[1];
    return 0;
}

T2 花匠

思路

真的贪心,假的DP

求一个最长波浪形子序列

贪心策略是,每个连续上升或者下降的子序列中,只有一个能选,所以我们直接统计一下波浪的数量,然后加上第一个就好了

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
int n;
int fro,pro=0;
int ans;
int main()
{
	cin>>n;
	cin>>fro;
	for(int i=2;i<=n;i++)
	{
		int x;
		cin>>x;
		if(x==fro)
		continue;
		if(pro!=1&&x>fro)//上升 
		{
			ans++;
			pro=1;
		}
		else if(pro!=2&&x<fro)
		{
			ans++;
			pro=2;
		}
		fro=x;
	}
	ans++;
	cout<<ans<<'\n';
	return 0;
}

T3 华容道

BFS搜索加暴力巨恶心卡常

但说实话,正解我不会

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <queue>
#include <deque>
using namespace std;
const int maxn=35;
inline int read()
{
	int x=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9')
	{
		if(c=='-') f=-1;
		c=getchar();
	}
	while(c>='0'&&c<='9')
	{
		x=(x<<1)+(x<<3)+c-'0';
		c=getchar();
	}
	return x*f;
}
inline void write(int x)
{
	if(x<0) putchar('-'),x=-x;
	if(x>9) write(x/10);
	putchar(x%10+'0');
}
struct node{
	int x,y,ddx,ddy,st;
};
int n,m,T;
int a[maxn][maxn];
bool vis[maxn][maxn][maxn][maxn];
int dx[]={0,0,1,0,-1};
int dy[]={0,1,0,-1,0};


int main()
{
	std::ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin>>n>>m>>T;
	for(register int i=1;i<=n;i++)
	{
		for(register int j=1;j<=m;j++)
		cin>>a[i][j];
	}
	while(T--)
	{
		deque <node> q;
		bool flag=false;
		memset(vis,false,sizeof(vis));
		int ex,ey,sx,sy,tx,ty;
		cin>>ex>>ey>>sx>>sy>>tx>>ty;

		node now;
		now=(node){sx,sy,ex,ey,0};
		vis[ex][ey][sx][sy]=true;
		q.push_back(now);
		while(q.size())
		{
			now=q.front();
			q.pop_front();
			int x=now.x;
			int y=now.y;
			int lx=now.ddx;
			int ly=now.ddy;
			if(x==tx&&y==ty) 
			{
				flag=true;
				cout<<now.st<<'\n';
				break;
			}
			
			int fx=lx+0,fy=ly+1;
			int vx,vy;
			if(fx<n||fy<m||fx>1||fy>1)
			{
				vx=x,vy=y;
				if(x==fx&&y==fy)
				vx=lx,vy=ly;
				if(a[fx][fy]&&!vis[fx][fy][vx][vy])
				{
					vis[fx][fy][vx][vy]=true;
					node nt;
					nt=(node){vx,vy,fx,fy,now.st+1};
					q.push_back(nt);
				}
			}
			
			fx=lx+1,fy=ly+0;
			if(fx<n||fy<m||fx>1||fy>1)
			{
				vx=x,vy=y;
				if(x==fx&&y==fy)
				vx=lx,vy=ly;
				if(a[fx][fy]&&!vis[fx][fy][vx][vy])
				{
					vis[fx][fy][vx][vy]=true;
					node nt;
					nt=(node){vx,vy,fx,fy,now.st+1};
					q.push_back(nt);
				}
			}
			
			fx=lx+0,fy=ly-1;
			if(fx<n||fy<m||fx>1||fy>1)
			{
				vx=x,vy=y;
				if(x==fx&&y==fy)
				vx=lx,vy=ly;
				if(a[fx][fy]&&!vis[fx][fy][vx][vy])
				{
					vis[fx][fy][vx][vy]=true;
					node nt;
					nt=(node){vx,vy,fx,fy,now.st+1};
					q.push_back(nt);
				}
			}
			
			fx=lx-1,fy=ly+0;
			if(fx<n||fy<m||fx>1||fy>1)
			{
				vx=x,vy=y;
				if(x==fx&&y==fy)
				vx=lx,vy=ly;
				if(a[fx][fy]&&!vis[fx][fy][vx][vy])
				{
					vis[fx][fy][vx][vy]=true;
					node nt;
					nt=(node){vx,vy,fx,fy,now.st+1};
					q.push_back(nt);
				}
			}
		}
		if(!flag) 
		cout<<-1<<'\n';
	}
	return 0;
}
posted @ 2021-11-11 23:45  wweiyi  阅读(20)  评论(0编辑  收藏  举报
js脚本