前言：

我參加了今年第八屆的藍橋杯國賽，只拿了個優秀獎，傷心。官方也沒有公佈試題和答案，在網上搜索了很久都沒有找到藍橋杯國賽的題目。突然有了一個不自量力的想法，趁還有一點記憶，把題目記錄下來，並且附上自己的做法。

第一題：36進位制

題意：

用類似16進位制的表示辦法，A表示10，B表示11，……，Y表示25，Z表示26，再加上0到9，就可以表示為36進位制。那麼請問MANY對應的十進位制數是多少？

程式碼：

#include<stdio.h>
int main()
{
	char ch[5] = "MANY";
	int ans = 0;
	for(int i = 0; i < 4; i++)
		ans = ans * 36 + (ch[i]-'A'+10);
	printf("%d\n", ans);
	return 0;
} 
 

參考答案：1040254

第二題：瓷磚樣式

題意：

有2種不同顏色規格為1*2的瓷磚，用其來鋪設地板，不能重疊和越界。並且，地板中任意2*2的格子不能為同一種顏色。如圖，當地板為2*3時，有10種鋪設方案。問：當地板為3*10時，問有多少種鋪設方案？

程式碼：

#include<stdio.h>
#include<string.h>
#define maxn 3
#define maxm 10
int a[maxn][maxm];
int ans;

bool check()
{
	for(int i = 0; i < maxn-1; i++)
		for(int j = 0; j < maxm-1; j++)
		{
			int p = a[i][j];
			if(p == -1) return false; //地板必須全部鋪滿
			if(p == a[i+1][j] && p == a[i][j+1] && p == a[i+1][j+1]) return false; //任意2*2格子不能為同一種顏色
		}
	return true;
}

void dfs(int cur) //準備鋪地板第cur格
{
	if(cur == maxn * maxm)
	{
		if(check())
		{
			ans++;
			/*
			for(int i = 0; i < maxn; i++)
			{
				for(int j = 0; j < maxm; j++) printf("%d", a[i][j]);
				printf("\n");
			}
			printf("-------\n");
			*/
		}
		return;
	}
	int x = (cur-1) / maxm;
	int y = cur - x * maxm -1;
	//格子(x,y)已經鋪有瓷磚
	if(a[x][y] != -1)
		dfs(cur+1);
	//橫著鋪
	if(y+1 < maxm && a[x][y] == -1 && a[x][y+1] == -1)
	{
		a[x][y] = a[x][y+1] = 0;
		dfs(cur+1);
		a[x][y] = a[x][y+1] = 1;
		dfs(cur+1);
		a[x][y] = a[x][y+1] = -1;
	}
	//豎著鋪
	if(x+1 < maxn && a[x][y] == -1 && a[x+1][y] == -1)
	{
		a[x][y] = a[x+1][y] = 0;
		dfs(cur+1);
		a[x][y] = a[x+1][y] = 1;
		dfs(cur+1);
		a[x][y] = a[x+1][y] = -1;
	}
}

int main()
{
	memset(a, -1, sizeof(a));
	ans = 0;
	dfs(1);
	printf("%d\n", ans);
	return 0;
}
 

參考答案：105760

第三題：希爾伯特曲線

題意：

有一個正方形，可以在上面作出一條希爾伯特曲線。左下角座標為(1,1)，右下角座標為(2^n, 2^n)。該曲線在2^(n+1)*2^(n+1)上的正方形上的圖案，可以由2^n * 2^n的情況構造出來。構造方法：左上角和右上角保持不變，左下角順時針90度，右下角逆時針90度，然後各部分按照虛線相連即可。有n<30，x,y<2^30。輸入n和p點座標(x, y)，答案輸出曲線上該點覆蓋的格子的序號。注：格子的序號是從(1,1)開始沿著曲線所覆蓋的第幾個格子。

程式碼：

#include<stdio.h>
long long f(int n, int x, int y)
{
	if(n == 0) return 1;
	long long m = 1LL << (n-1);
	if(x <= m && y <= m)
		return f(n-1, y, x);
	if(x > m && y <= m)
		return 3LL * m * m + f(n-1,      ,2*m-x+1); //填空
	if(x <= m && y > m)
		return 1LL * m * m + f(n-1, x, y-m);
	if(x > m && y > m)
		return 2LL * m * m + f(n-1, x-m, y-m);
}
int main()
{
	int n, x, y;
	scanf("%d %d %d", &n, &x, &y);
	printf("%lld\n", f(n, x, y));
	return 0;
}
 

參考答案：m-y+1

【解釋】給出的程式碼是使用分治法，通過分析給出的4個if語句可以判斷出依次是處理左下、右下、左上、右上，需要我們填空的部分是處理右下角的。分治法是將大問題變為相同性質的小問題，因此是要將右下角的圖形逆時針90度。

假設正方形是m*m，那麼順時針90度，就是將第1行變為第1列，第2行變為第2列，……第m行變為第m列。而逆時針90度，就是將第1行變為第m列，第2行變為第m-1列，……，第m行變為第1列。右下角的部分需要縱座標平移m個單位後，再逆時針90度。

順時針90度：(x, y) ==> (y, x)

逆時針90度：(x, y) ==> (m-y+1, m-x+1)

第四題：找環

題意：

編號為1到n的n個點，以及n-1條邊構成一棵樹。現在在樹上加上一條邊，這樣就構成了一個含環的圖了。請你找出該環上的結點，從小到大輸出這些結點編號。

測試資料：

30%資料：n<1000

100%資料：n<100000

輸入樣例：

5

1 2

2 5

4 2

1 3

5 3
輸出樣例：

1 2 3 5

【題解】

計算出每個點的度數。明顯度數為1的點不可能在環上，那麼與該點唯一相連的邊也就不在環上了，可以刪去。刪去這條邊後，這邊的另一個端點度數減去1，如果因此而導致它的度數變為1了，同樣說明該點不在環上，可以去掉，不斷重複以上操作，直到沒有邊可以刪去。

參考程式碼中用一個佇列來維護邊。由於點數n很大，無法使用鄰接矩陣，只能使用鄰接表來儲存圖，程式碼中使用vector容器來實現。

參考程式碼：

#include<stdio.h>
#include<string.h>
#include<vector>
#include<queue>
using namespace std;
#define maxn 100010
int d[maxn];
vector<int> e[maxn];
typedef struct EDGE
{
	int u, v;
	EDGE(int a=0, int b=0):u(a),v(b){}
}Edge;
queue<Edge> q;
int n;
void init()
{
	memset(d, 0, sizeof(d));
    scanf("%d", &n);
	int a, b;
	for(int i = 1; i <= n; i++)
	{
		scanf("%d %d", &a, &b);
		d[a]++;
		d[b]++;
		e[a].push_back(b);
		e[b].push_back(a);
		q.push(Edge(a,b));
	}
}
void out()
{
	bool flag = false;
	for(int i = 1; i <= n; i++)
		if(d[i] > 0)
		{
			if(!flag){ printf("%d", i); flag = true; }
			else
				printf(" %d", i);
		}
		putchar('\n');
}

void solve()
{
	while(!q.empty())
	{
		Edge tmp = q.front();  q.pop();
		if(d[tmp.u] == 1 || d[tmp.v] == 1) //其中一個端點的度為1時，刪去該邊
		{
			d[tmp.u]--;
			d[tmp.v]--;
			int p;
			if(d[tmp.u] == 1) 
			{
				p = tmp.u;
				int size = e[p].size();
				for(int i = 0; i < size; i++)
				{
					int t = e[p][i];
					if(d[t] > 0) q.push(Edge(p, t));
				}
			}
			if(d[tmp.v] == 1) 
			{
				p = tmp.u;
				int size = e[p].size();
				for(int i = 0; i < size; i++)
				{
					int t = e[p][i];
					if(d[t] > 0) q.push(Edge(p, t));
				}
			}
		}
	}
}

int main()
{
	init();
	solve();
	out();
	return 0;
}

第五題：線上匹配

題意：

有n個人在線上玩遊戲，每人的積分分別為Ai。如果線上的某兩個人的積分恰好相差為k時，他們就會被進行匹配。問線上最多會有多少人，他們任意兩人均沒法進行匹配？

測試資料：

30%資料：n<10

100%資料：n<100000，Ai<100000，k<100000

輸入樣例1：

10 0

1 4 2 3 6 7 1 4 2 3

輸出樣例1：

6

輸入樣例2：

10 3

1 1 1 1 4 4 1 1 1 1

輸出樣例2：

8

【題解】

方法一：

30%資料n<10，所以可以用深度搜索，每個數只有選和不選，得到一組待定的數列後，再檢查一下是否兩兩不能匹配，是則用當前數列的個數去嘗試更新答案。時間複雜度是O(n*2^n)。

方法二：

將每個數值看作點，把可以匹配的兩個數連一條邊，那麼問題轉化為：刪去最少的點，使得剩下的點中不存在相連的邊。

對於每條邊，明顯兩個端點只能選一個，按照貪心思想，易知應該優先去掉度數多的那個點。

演算法步驟：

(1)構圖，將積分恰好相差k的兩個點相連；

(2)計算出所有點的度數；

(3)找出度數最大的那個點；

(4)把與該點相連的所有點的度數減去1，把該點的度數置為-1表示已經刪去該點；

(5)重複(4)(5)，直到沒有邊可以刪去；

(6)這時剩餘的點的度數均為0，統計出其個數，就是最大不能兩兩匹配的個數。

時間複雜度為O(n^2)

（n<100000，該方法仍然無法通過所有測試資料，希望有大神能夠提供更優秀的方法）

參考程式碼：

#include<stdio.h>
#include<string.h>
#include<vector>
using namespace std;
#define maxn 100010
vector<int> e[maxn];
int a[maxn]; //a[i]表示第i個人的積分
int d[maxn];  //d[i]表示第i個點的度數
bool exist[maxn]; //exist[i]=false表示第i個點刪去
int n, k;

void init()
{
	scanf("%d %d", &n, &k);
	for(int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);
	}
}

void out()
{
	int ans = 0;
	for(int i = 1; i <= n; i++)
		if(exist[i]) ans++;
	printf("%d\n", ans);
}
void solve()
{
	memset(d, 0, sizeof(d));
	int i, j;
	for(i = 1; i < n; i++)
		for(j = i+1; j <= n; j++)
		{
			if(a[i] - a[j] == k || a[j] - a[i] == k)
			{
				e[i].push_back(j);
				e[j].push_back(i);
				d[i]++;
				d[j]++;
			}
		}
	
	memset(exist, true, sizeof(exist));
	do{
		int maxv = 0, sign = -1;
		int i;
		for(i = 1; i <= n; i++)
			if(exist[i])
			{
				if(d[i] > maxv) maxv = d[sign = i];
			}
		if(maxv == 0) 
			break;
		else{
			int size = e[sign].size();
			for(i = 0; i < size; i++)
			{
				int p = e[sign][i];
				if(exist[p]) d[p]--;
			}
			exist[sign] = false;
			d[sign] = -1;
		}
	}while(1);
}

int main()
{
	init();
	solve();
	out();
	return 0;
}

第六題：觀光鐵路

【題解】

這題我也沒有什麼思路，還沒想到什麼解決方法。