2018年全国多校算法寒假训练营练习比赛（第四场）题解

传送门：第四场






A.石油采集


题目大意：
用 2*1 的方格覆盖图中的两个相连的‘#’，问在不重复的情况下最多可以覆盖多少个。

思路1：
对于某个坐标为 (x,y) 的 #，它只能与其上下左右四个 # 相连接。该点与其相邻的四个点的坐标和的奇偶性不同。也就是说坐标和为奇数的 # 只能与坐标和为偶数的 # 相连接。所以我们可以用 DFS 搜索每一片相连的 # 中坐标和为奇数和为偶数的各有多少个，取最小值加到结果中就行了。

思路2：
第二种思路是求二分图的最大匹配，比较麻烦一点，难在建图。上面提到坐标和为奇数的 # 只能与坐标和为偶数的 # 相连接，所以我们可以把坐标和奇偶性不同的点当作二分图中两个不同的点集，这样一来就转换成了求二分图的最大匹配。

建图的时候，我是先遍历一遍对坐标和为奇数和为偶数的 # 点编号，然后再遍历一遍对相连接的点建图。之后就套用求二分图最大匹配的模板即可。

代码1：#include<stdio.h>
#include<string.h>

int n,ji,ou,dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
char mp[55][55];

int min(int
4000
a,int b)
{
return a<b? a:b;
}

void dfs(int x,int y)
{ //寻找与当前点相连的 #中坐标和为奇数和偶数的个数
if(x<0||x>=n||y<0||y>=n||mp[x][y]=='.') return;
int i;
if((x+y)%2==0) ou++; //坐标和为偶数
else ji++;
mp[x][y]='.';
for(i=0;i<4;i++) //对上下左右四个方向搜索
dfs(x+dx[i],y+dy[i]);
}

int main()
{
int i,j,t,cas,ans;
scanf("%d",&t);
cas=1;
while(t--)
{
scanf("%d",&n);
for(i=0;i<n;i++) scanf("%s",mp[i]);
ans=0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(mp[i][j]=='#')
{ //如果当前字符为 #，则寻找与其相连的 #中坐标和为奇数和偶数的个数
ji=ou=0;
dfs(i,j);
ans+=min(ji,ou); //取最小值加到结果
}
printf("Case %d: %d\n",cas++,ans);
}
return 0;
}
代码2：#include<stdio.h>
#include<string.h>

int vis[2505]; //节点是否访问过
int link[2505]; //与该节点相连接节点的编号
int mp[2505][2505];//值为1表示u，v节点有边
int gn,gm; //二分图两部分的节点数，两部分的节点编号都是从1开始

int find(int u)
{ //匈牙利算法
int i;
for(i=1;i<=gm;i++)
{
if(mp[u][i] && vis[i]==0) //如果节点i与v相连并且未被查找过
{
vis[i]=1; //标记i为已查找过
if(link[i]==-1 || find(link[i])) //如果i未在前一个匹配M中，或者i在匹配M中，但是从与i相邻的节点出发可以有增广路径
{
link[i]=u; //记录查找成功记录，更新匹配M（即“取反”）
return 1; //返回查找成功
}
}
}
return 0;
}

int main()
{
int i,j,k,t,n,m,u,v,num,cas,a[55][55];
int x,y,dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
char s[55][55];
scanf("%d",&t);
cas=1;
while(t--)
{
scanf("%d",&n);
for(i=0;i<n;i++) scanf("%s",s[i]);
gn=gm=0;
memset(a,0,sizeof(a));
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(s[i][j]=='#')
{ //先遍历一遍对坐标和为奇数和偶数的点分别编号
if((i+j)%2==1) a[i][j]=++gn; //坐标和为奇数
else a[i][j]=++gm;
}
memset(mp,0,sizeof(mp));
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(a[i][j])
{ //遍历一遍建图
for(k=0;k<4;k++)
{ //当前点可以和上下左右四个点连接
x=i+dx[k]; //相邻点坐标
y=j+dy[k];
if(a[x][y])
{ //如果为 #
//注意坐标和奇偶性不同时建图也不同
if((i+j)%2==1) mp[a[i][j]][a[x][y]]=1; //为奇数
else mp[a[x][y]][a[i][j]]=1; //为偶数
}
}
}
num=0;
for(i=1;i<=gm;i++) link[i]=-1;
for(i=1;i<=gn;i++)
{ //求二分图的最大匹配
memset(vis,0,sizeof(vis));
if(find(i)) num++;
}
printf("Case %d: %d\n",cas++,num);
}
return 0;
}


B.道路建设

题目大意：
告诉你城市数和要建的每条道路连接的城市和花费，问要让所有城市都连接起来经费是否够。


思路：
最小生成树。基于并查集写的。

代码：#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;

struct node
{
int u,v,w;
} a[10010];

int cmp(node x,node y)
{
return x.w<y.w;
}

int f[110];

void init(int n)
{
int i;
for(i=0;i<=n;i++) f[i]=i;
}

int find(int x)
{ //查找 x 所属的集合
if(x!=f[x]) f[x]=find(f[x]);
return f[x];
}

int Union(int x,int y)
{ //和并 x y 所在的集合
int fx,fy;
fx=find(x);
fy=find(y);
if(fx==fy) return 0;
f[fx]=fy;
return 1;
}

int main()
{
int i,c,n,m,num,ans;
while(~scanf("%d%d%d",&c,&n,&m))
{
init(m);
for(i=0;i<n;i++) scanf("%d%d%d",&a[i].u,&a[i].v,&a[i].w);
sort(a,a+n,cmp); //按花费升序排列
ans=num=0;
for(i=0;i<n;i++)
{ //找 m-1 条可以生成最小生成树的边
if(Union(a[i].u,a[i].v))
{
num++;
ans+=a[i].w;
if(num==m-1) break;
}
}
if(ans<=c) printf("Yes\n");
else printf("No\n");
}
return 0;
}

C.求交集


题目大意：
给你两个升序排列的集合，求出两个集合的交集。


思路：
如果两个集合是乱序的，则复杂度为 O(n*m)，不过由于是有序的所以有 O(n+m) 的方法。即每次拿出两个集合中最小的数相比较，如果相等就加到结果队列中，如果不等则小的一方的指针就前进一步。

代码：#include<stdio.h>
#include<string.h>

int a[1000010],b[1000010],ans[1000010];

int main()
{
int i,j,n,m,tol;
while(~scanf("%d%d",&n,&m))
{
for(i=0;i<n;i++) scanf("%d",&a[i]);
for(i=0;i<m;i++) scanf("%d",&b[i]);
i=j=tol=0; //i j分别指向 a b数组当前元素
while(i<n&&j<m)
{
if(a[i]==b[j])
{ //如果相等则加到结果队列且指针都往前一步
ans[tol++]=a[i];
i++;
j++;
}
else if(a[i]<b[j]) i++; //反之小的一方的指针往前进一步
else j++;
}
if(tol==0) printf("empty\n");
else
{
printf("%d",ans[0]);
for(i=1;i<tol;i++) printf(" %d",ans[i]);
printf("\n");
}
}
return 0;
}

E.通知小弟


题目大意：
一个间谍网之间的间谍只能单向联系，消息可以不断传递。他们的老大能联系到其中的几个人，问老大最少通知几个人就可以通知到所有的人。


思路：
如果间谍网是有向无环图的话，则老大如果能联系到入度为 0的点（即别人都无法联系到的人）就能通知到所有的人，但是这个图不是有向无环图，所以可以用 Tarjan算法求图的强连通分量并缩点，这样就可以得到一个有向无环图。

我们将老大可以通知到的间谍所在的强联通分量标记一下，看是否所有的强联通分量都被标记了，如果不是则说明有人通知不到。反之我们看一下老大能通知到入度为 0 的点的个数。


代码：#include<stdio.h>
#include<string.h>
#include<stack>
#include<vector>
#include<iostream>
using namespace std;

#define MAXN 505

int n,m;
//dfn记录节点的被访问时间（时间戳）
//low记录该点或者以这个点为根的子树能够追溯到最早的栈中节点的次序
int dfn[MAXN],low[MAXN];
//vis标记是否在栈中，num为每个强连通分量的节点数，belong标记节点属于第几个强连通分量
int vis[MAXN],num[MAXN],belong[MAXN];
int cnt,idx; //cnt为强连通分量的个数，idx为节点访问的编号（每个节点不同）
stack<int> s;
vector<int> map[MAXN];

void tarjan(int u)
{
int i,v;
dfn[u]=low[u]=++idx; //新点初始化
s.push(u); //入栈
vis[u]=1; //标记在栈中
for(i=0;i<map[u].size();i++)
{ //处理与u相邻的节点
v=map[u][i];
if(!dfn[v])
{ //如果没被访问过,不能用!vis[v]，vis表示是否在栈中
tarjan(v); //递归处理
if(low[v]<low[u]) low[u]=low[v]; //将强连通分量的所有节点low值改为根节点的dfn值
}
//如果访问过，并且在栈中，表明存在环
else if(vis[v]&&dfn[v]<low[u]) low[u]=dfn[v];
}
if(dfn[u]==low[u])
{ //如果是强连通分量子树的最小根，此时栈内u之上的元素构成起一个强连通分量
cnt++; //第cnt个强连通分量
do
{ //输出 也可以开个vector数组存储一下
v=s.top();
s.pop();
vis[v]=0; //标记不在栈中
belong[v]=cnt; //节点v属于第cnt个强连通分量
num[cnt]++;
} while(u!=v);
}
}

void solve()
{
int i;
cnt=0;
idx=0;
memset(dfn,0,sizeof(dfn));
memset(low,0,sizeof(low));
memset(vis,0,sizeof(vis));
memset(num,0,sizeof(num));
for(i=1;i<=n;i++) //如果没被访问过则从该点开始处理，防止有点遗漏
if(!dfn[i]) tarjan(i);
}

vector<int> mp[MAXN]; //由所有强连通分量形成的新图
int ru[MAXN]; //入度

void suodian(int n)
{ //缩点函数，其中n为节点个数
int i,j,u,v;
memset(ru,0,sizeof(ru));
for(i=1;i<=n;i++) mp[i].clear();
for(i=1;i<=n;i++)
{ //扫描每个节点
u=belong[i]; //原来起点所在的强连通分量
for(j=0;j<map[i].size();j++)
{ //每个节点的相邻节点
v=belong[map[i][j]]; //原来终点所在的强连通分量
if(u!=v)
{ //如果不在同一强连通分量内
mp[u].push_back(v); //形成新图
ru[v]++;
}
}
}
}

int main()
{
int i,j,x,f,sum,ans,a[505],mark[505];
while(~scanf("%d%d",&n,&m))
{
for(i=0;i<=n;i++) map[i].clear();
for(i=0;i<m;i++) scanf("%d",&a[i]);
for(i=1;i<=n;i++)
{
scanf("%d",&sum);
for(j=0;j<sum;j++)
{
scanf("%d",&x);
map[i].push_back(x);
}
}
solve();
suodian(n);
memset(mark,0,sizeof(mark));
//将能通知到的人所在的强联通分量标记
for(i=0;i<m;i++) mark[belong[a[i]]]=1;
f=1;
ans=0;
//printf("cnt=%d\n",cnt);
for(i=1;i<=cnt;i++)
{ //
if(!mark[i]&&!ru[i])
{ //如果有人没通知到且没人通知的到
f=0;
break;
}
//如果此人没人通知的到并且间谍老大可以通知到
else if(!ru[i]&&mark[i]) ans++;
}
if(!f) printf("-1\n");
else printf("%d\n",ans);
}
return 0;


F. Call to your teacher

题目大意：
给出多条可单向联系的边，问编号为 1 的节点能否直接或间接联系到编号为 n 的节点。

思路：
深搜。不过需要注意的是对于访问过的每个点我们需要标志访问过，下次递归就不用考虑了，否则会超内存。


代码：#include<stdio.h>
#include<string.h>
#include<iostream>
#include<vector>
using namespace std;

int n,f,vis[55];
vector<int> mp[55];

void dfs(int nd)
{
int i,v;
if(f) return;
vis[nd]=1;
for(i=0;i<mp[nd].size()&&!f;i++)
{ //搜索与其相连的点
v=mp[nd][i];
if(v==n)
{
f=1;
return;
}
if(!vis[v]) dfs(v); //如果没访问过则搜索
//vis[v]=1;
}
}

int main()
{
int i,m,a,b;
while(~scanf("%d%d",&n,&m))
{
for(i=0;i<=n;i++) mp[i].clear();
for(i=0;i<m;i++)
{
scanf("%d%d",&a,&b);
mp[a].push_back(b);
}
f=0;
memset(vis,0,sizeof(vis));
dfs(1);
if(f) printf("Yes\n");
else printf("No\n");
}
return 0;
}

H.老子的全排列呢

题目大意：
按顺序输出 12345678 可以组成的所有排列。


思路：
直接调用函数即可，也可以自己写递归解决。


代码：#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
int a[10]={1,2,3,4,5,6,7,8};
printf("1 2 3 4 5 6 7 8\n");
while(next_permutation(a,a+8))
{
printf("%d %d %d %d %d %d %d %d\n",a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
}
return 0;
}