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

A.石油采集/********************************************************************************************************
Date : 2018/2/11
Author: Wen Yaxin

解题思路：对图中#号点进行编号并对相邻#号构建图，
然后对整个图进行一个二分图匹配，最终二分图的最大
匹配就是答案。

变量解释:
Map :Map[i][j]是i行j列点的编号。
head :head[i]代表以i为起始的边的链表的头节点
cnt :用来向edge数组中加边用的数组下标
vis :用来标记某个点是否被访问过
match:match[i]存放与节点i匹配的点
dir :dir用来存放方向，分别是向左一格和向右一格
edge :存放边，由相邻的#的编号构成的图的边
*********************************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

const int maxn = 1e6;
int Map[505][505];
int head[maxn],cnt,vis[maxn],match[maxn];
int dir[2][2] = {{-1,0},{0,-1}};
struct Edge {
int v;
int nex;
}edge[maxn];
void addEdge(int u,int v) {
edge[cnt].v = v;
edge[cnt].nex = head[u];
head[u] = cnt++;

edge[cnt].v = u;
edge[cnt].nex = head[v];
head[v] = cnt++;
}
bool hungry(int x) {
for(int i = head[x]; i != -1; i=edge[i].nex) {
int y = edge[i].v;
if(vis[y] == 0) {
vis[y] = 1;
if(match[y]==-1 || hungry(match[y])) {
match[y] = x;
match[x] = y;
return true;
}
}
}
return false;
}
int solve(int num) {
int ans = 0;
memset(match,-1,sizeof(match));
for(int i = 1; i < num; i++) {
memset(vis,0,sizeof(vis));
if(match[i] == -1) {
if(hungry(i)) {
ans++;
}
}
}
return ans;
}
int main() {
int T,N,Case=0;
scanf("%d",&T);
while(T--) {
scanf("%d",&N);
cnt = 0;
memset(head,-1,sizeof(head));
memset(Map,-1,sizeof(Map));
int index = 0;
char ch;
int dx,dy;
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
scanf(" %c",&ch);
if(ch == '#') {
Map[i][j] = index++;
for(int k = 0; k < 2; k++) {
dx = i + dir[k][0];
dy = j + dir[k][1];
if(dx>=0 && dy>=0 && Map[dx][dy] != -1) {
addEdge(Map[i][j],Map[dx][dy]);
}
}
}
}
}
printf("Case %d: %d\n",++Case,solve(index));
}
return 0;
}B.道路建设/*******************************************************************************************
Date : 2018/2/11
Author: Wen Yaxin

解题思路：求图的最小生成树，我用的是克鲁斯卡尔算法，
因为这个图是对无向图无定点求最小生成树的。

变量解释:
C：资金
N: 道路条数
M: 城市个数
f: f[i]代表定点i所在的集合，用于完成并查集操作
****************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;

const int maxn = 1e4+10;
int C,N,M;
int f[maxn];
//初始化集合
void initSet() {
for(int i = 1; i <= M; i++) {
f[i] = i;
}
}
//寻找顶点x所在的集合
int findSet(int x) {
while(x!=f[x]) {
x = f[x];
}
return x;
}
//合并集合x,y
void unionSet(int x,int y) {
f[x] = y;
}
struct Edge {
int u;
int v;
int cost;
}edge[maxn];
//以边的权值从小到大排序
bool cmp(Edge e1,Edge e2) {
return e1.cost<e2.cost;
}
//克鲁斯卡尔算法求最小生成树
bool Kruskal() {
int i,j,u1,v1,sn1,sn2;
i = 0;
j = 0;
int sum = 0;
while(j < N) {
u1 = edge[j].u;
v1 = edge[j].v;
sn1 = findSet(u1);
sn2 = findSet(v1);
if(sn1 != sn2) {
sum = sum + edge[j].cost;
i++;
unionSet(sn1,sn2);
}
j++;
}
if(i == M-1) {
if(sum <= C) {
return true;
}
else {
return false;
}
}
return false;
}
int main() {
while(~scanf("%d%d%d",&C,&N,&M)) {
int u,v,cost;
initSet(); //初始化集合
for(int i = 0; i < N; i++) {
scanf("%d%d%d",&u,&v,&cost);
edge[i].u = u;
edge[i].v = v;
edge[i].cost = cost;
}
sort(edge,edge+N,cmp);
if(Kruskal()) {
printf("Yes\n");
}
else {
printf("No\n");
}
}
return 0;
}
C.求交集/*************************************************************************************
Date : 2018/2/11
Author: Wen Yaxin

解题思路：排序算法之二路归并排序算法的应用

变量解释:
s1:集合1
s2:集合2
s3:盛放结合1和集合2排序之后
ans:存放答案
**********************************************************************************/
#include <iostream>
#include <stdio.h>
#include <queue>
#include <string.h>

using namespace std;

const int maxn = 1000010;
int N,M;
int s1[maxn],s2[maxn],s3[maxn<<1],ans[maxn];
//二路归并
void unionSort() {
int i,j,k;
i = 0;
j = 0;
k = 0;
while(i < N && j < M) {
if(s1[i]<s2[j]) {
s3[k++] = s1[i];
i++;
}
else {
s3[k++] = s2[j];
j++;
}
}
if(i == N) {
while(j < M) {
s3[k++] = s2[j++];
}
}
if(j == M) {
while(i < N) {
s3[k++] = s1[i++];
}
}
}
int main() {
while(~scanf("%d%d",&N,&M)){
for(int i = 0; i < N; i++) {
scanf("%d",&s1[i]);
}
for(int i = 0; i < M; i++) {
scanf("%d",&s2[i]);
}
unionSort();
int cnt = 0;
for(int i = 1; i < M+N; i++) {
if(s3[i] == s3[i-1]) {
if(cnt == 0) {
ans[cnt++] = s3[i];
}
else if(s3[i] != ans[cnt]) {
ans[cnt++] = s3[i];
}
}
}
if(cnt == 0) {
printf("empty\n");
}
else {
for(int i = 0; i < cnt; i++) {
if(i != 0) {
printf(" ");
}
printf("%d",ans[i]);
}
printf("\n");
}
}
return 0;
}D.小明的挖矿之旅/*********************************************************************************************
Date : 2018/2/17 22:04
Author: Wen Yaxin

解题思路：统计入度为0和出度为0的点数，要两者的
最大值。特殊情况，整个图只有一个有金子的地方，
不需要传送门。

变量解释:
Map:图
n :行数
m :列数
**************************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

char Map[1010][1010];
int n, m;

int main()
{
int ans1 = 0, ans2 = 0, cnt = 0;
while(~scanf("%d%d", &n, &m))
{
memset(Map, 0, sizeof(Map));
for(int i = 1; i <= n; i++)
scanf("%s", Map[i] + 1);
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(Map[i][j] == '.') cnt++;
//一个点上方的左方均不可达，该点不可达。
if(Map[i][j] != '#' && Map[i - 1][j] != '.' && Map[i][j - 1] != '.')
ans1++;
//一个点下方和右方均不可达，则到该点后不可走。
if(Map[i][j] != '#' && Map[i + 1][j] != '.' && Map[i][j + 1] != '.')
ans2++;
}
}
if(cnt <= 1) {
printf("0\n");
}
else {
printf("%d\n",max(ans1, ans2));
}
}
return 0;
}E.通知小弟/*********************************************************************************
Date : 2018/2/17
Author: Wen Yaxin

解题思路：统计相邻点的入度，入度为0直接处理，否则该点通过
其他相邻点可能到达，先不做处理，经过该处理后，如果某个
相邻点还没有访问到，再从该点进行搜索，最后如果还有点没有
访问到，则答案是-1，否则是最少通知的人数。

变量解释:
edge:存放图中的边
ans :答案
N,M :N间谍数量，M头领可以直接通知的人数
edgeNum:边的数目
head:head[i]存放以i为出边的所有边的头节点
in:统计节点的入度
vis:标记某个节点是否访问过
arr:存放于头领相邻的人员的编号
****************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

const int maxn = 5*1e6;
const int maxm = 600;
struct Edge {
int v;
int nex;
}edge[maxn];
int ans,N,M,edgeNum,head[maxm],in[maxm],vis[maxm],arr[maxm];
//初始化
void init() {
ans = 0;
edgeNum = 0;
memset(in,0,sizeof(in));
memset(vis,0,sizeof(vis));
memset(head,-1,sizeof(head));
}
//加边函数
void addEdge(int u,int v) {
edge[edgeNum].v = v;
edge[edgeNum].nex = head[u];
head[u] = edgeNum++;
}
//以某点为起点进行dfs
void dfs(int x) {
vis[x] = 1;
for(int i = head[x]; i != -1; i = edge[i].nex) {
int v = edge[i].v;
if(!vis[v]) {
dfs(v);
}
}
}
int main() {
while(~scanf("%d%d",&N,&M)) {
init();
for(int i = 0; i < M; i++) {
scanf("%d",&arr[i]);
}
int num,v;
for(int i = 1; i <= N; i++) {
scanf("%d",&num);
while(num--) {
scanf("%d",&v);
addEdge(i,v);
in[v]++;
}
}
for(int i = 0; i < M; i++) {
if(!in[arr[i]]) {
ans++;
dfs(arr[i]);
}
}
for(int i = 0; i < M; i++) {
if(!vis[arr[i]]) {
ans++;
dfs(arr[i]);
}
}
for(int i = 1; i <= N; i++) {
if(!vis[i]) {
ans = -1;
break;
}
}
printf("%d\n",ans);
}
return 0;
}F.Call to your teacher/************************************************************************************
Date : 2018/2/11
Author: Wen Yaxin

解题思路：简单BFS

变量解释:
head:head[i]存放以i为出边的链表的表头
vis :vis[i]标记某个节点i是否访问过
N :N个人
M :M种关系
************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <queue>
#include <string.h>

using namespace std;

const int maxn = 2010;
int head[maxn],vis[maxn];
int N,M,cnt;
struct edge{
int v;
int nex;
}edge[maxn];
void addEdge(int x,int y) {
edge[cnt].v = y;
edge[cnt].nex = head[x];
head[x] = cnt++;
}
bool bfs() {
memset(vis,0,sizeof(vis));
vis[1] = 1;
queue<int>qu;
qu.push(1);
int cur,nex;
while(!qu.empty()) {
cur = qu.front();
qu.pop();
if(cur == N) {
return true;
}
for(int i = head[cur]; i != -1; i = edge[i].nex) {
nex = edge[i].v;
if(vis[nex] == 0) {
qu.push(nex);
vis[nex] = 1;
}
}
}
return false;
}
int main() {
while(~scanf("%d%d",&N,&M)){
cnt = 0;
memset(head,-1,sizeof(head));
int u,v;
for(int i = 0; i < M; i++) {
scanf("%d%d",&u,&v);
addEdge(u,v);
}
if(bfs()) {
printf("Yes\n");
}
else {
printf("No\n");
}
}
return 0;
}G.老子的意大利炮呢/*************************************************************************************************
Date : 2018/2/17 22:55
Author: Wen Yaxin

解题思路：求终点到三个点的最短路，然后对三个部分的
先后顺序进行枚举。

变量解释:
inf :无穷大。
dist:dist[x][y]存放终点到(x,y)的距离。
a :存放意大利炮三个部分的下标，用来求下标的全排列
sx,sy:起点横纵坐标
ex,ey:终点横纵坐标
n,m :行数，列数
Map :图
dir :搜索的四个方向
p :意大利炮三个部分的坐标
******************************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;

const int inf = 0x3f3f3f3f;
const int maxn = 105;
int dist[maxn][maxn],a[3];
int sx,sy,ex,ey,n,m;
char Map[maxn][maxn];
int dir[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};
struct Point {
int x,y,t;
}p[3];
//求终点到三个部分的距离
void bfs() {
int v,x,y,dx,dy;
memset(dist,-1,sizeof(dist));
queue<int>qu;
dist[ex][ey] = 0;
//把坐标映射成它是这个图上的第几个点
v = ex*m + ey;
qu.push(v);
while(!qu.empty()) {
v = qu.front();
qu.pop();
x = v/m;
y = v%m;
for(int i = 0; i < 4; i++) {
dx = x + dir[i][0];
dy = y + dir[i][1];
if(dx>=0&&dx<n&&dy>=0&&dy<m&&dist[dx][dy]==-1&&Map[dx][dy]=='.'){
dist[dx][dy] = dist[x][y] + 1;
qu.push(dx*m+dy);
}
}
}
return;
}
int main() {
while(~scanf("%d%d",&n,&m)) {
for(int i = 0; i < n; i++) {
scanf("%s",Map[i]);
}
scanf("%d%d",&sx,&sy);
//图输入时往左上平移了，输入的坐标同样要往左上平移。
sx--;
sy--;
for(int i = 0; i < 3; i++) {
scanf("%d%d",&p[i].x,&p[i].y);
p[i].x--;
p[i].y--;
}
scanf("%d%d",&ex,&ey);
ex--;
ey--;
bfs();
for(int i = 0; i < 3; i++) {
scanf("%d",&p[i].t);
a[i] = i;
}
int temp,ans=inf,distij,distjk,i,j,k;
//顺序start->p[i]->p[j]->p[k]->终点
do {
i = a[0];
j = a[1];
k = a[2];
temp = abs(p[i].x-sx) + abs(p[i].y-sy);
distij = abs(p[j].x-p[i].x) + abs(p[j].y-p[i].y);
temp = temp + (p[i].t+1)*distij;
distjk = abs(p[k].x-p[j].x) + abs(p[k].y-p[j].y);
temp = temp + (p[j].t+p[i].t+1)*distjk;
if(dist[p[k].x][p[k].y] != -1) {
temp = temp + (p[k].t+p[j].t+p[i].t+1)*dist[p[k].x][p[k].y];
if(temp < ans) {
ans = temp;
}
}
}while(next_permutation(a,a+3)); //对下标进行全排列
printf("%d\n",ans);
}
return 0;
}H.劳子的全排列呢/**************************************************************************************
Date : 2018/2/11
Author: Wen Yaxin

解题思路：dfs求全排列或C++中STL函数next_permutation
去求解。

变量解释:
a:该数组存放数字1~8
*************************************************************************************/
#include <iostream>
#include <stdio.h>
#include <algorithm>

using namespace std;

int a[10];
//该函数用来求1~X的全排列
void fun(int x) {
for(int i = 0; i < x; i++) {
a[i] = i+1;
}
do{
for(int i = 0; i < x; i++) {
printf("%d",a[i]);
if(i != x-1) {
printf(" ");
}
}
printf("\n");
}while(next_permutation(a,a+x));
}
int main() {
fun(8);
return 0;
}