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;
}