2016級資料結構第一次上機解題報告
A:
A題只要按照題目要求做就行，因為按值傳遞是不會改變原來變數的值的，而傳入引用和指標都會改變原來的資料，所以第一行輸出是a，b，其餘兩行是b，a，
參考程式碼：
#include <iostream> void swap1(int a, int b) { int hold = a; a= b; b= hold; } void swap2(int& a, int& b) { int hold = a; a= b; b= hold; } void swap3(int* a, int* b) { int hold = *a; *a = *b; *b = hold; } int main() { int a, b; while(std::cin >> a >> b) { int a1 = a, b1 = b; swap1(a1, b1); std::cout << a1 << " " << b1 <<"\n"; int a2 = a, b2 = b; swap2(a2, b2); std::cout << a2 << " " << b2 <<"\n"; int a3 = a, b3 = b; swap3(&a3, &b3); std::cout << a3 << " " << b3 <<"\n"; } }
B
一道大水題。
只需要找到“中間巧克力”，即從此塊巧克力開始，吃掉此塊巧克力（包括此塊）之前所有巧克力的時間和*2>吃掉所有巧克力的總時間。然後只需比較這塊巧克力被誰吃，如果吃掉這塊巧克力左面的巧克力所需要的時間<吃掉這塊巧克力右面的巧克力所需要的時間，則這塊巧克力被Syw吃，反之被Gzh吃，詳情請看程式碼。
#include <iostream> using namespace std; long long sum[100001]; int main() { int n,pos;//pos記錄中間巧克力的位置 while(cin>>n) { cin>>sum[1]; for(int i=2;i<=n;i++) { cin>>sum[i]; sum[i]+=sum[i-1]; }//sum記錄吃掉前n塊巧克力所需的時間 for(int i=1;i<=n;i++) if(sum[i]*2>=sum[n]) { pos=i; break; } if(sum[n]-sum[pos]<sum[pos-1]) pos--; cout<<pos<<' '<<n-pos<<endl; } return 0; }
C：
有些同學可能沒有讀懂，在這裡把樣例解釋清楚一些，一開始給他們標號，分別為1-3號男生，1-3號女生，排完隊後男生佇列是2 1 3，女生佇列是1 3 2，所以先輸出2號男生對應舞伴即2號女生的位置：3，然後輸出排在第二位的男生即1號男生對應的女生1號，而女生1號排在女生隊伍裡的第一個，所以輸出1，其實這道題暴力找是可以做的，還可以按照hint的思路，先給每個人標一個序號，然後排序，然後輸出每個人對應的舞伴的位置。
參考程式碼：
#include<cstdio> #include<algorithm> const int maxt = 10001; struct student { double h; int i; bool operator <(student const &o) const { return h < o.h; } }; int position[maxt]; student girl[maxt], boy[maxt]; int main() { int n; while(scanf("%d", &n) == 1) { for(int i = 1; i <= n; ++i) { scanf("%lf %lf", &girl[i].h, &boy[i].h); girl[i].i = boy[i].i = i; } std::sort(girl + 1, girl + 1 + n); std::sort(boy + 1, boy + 1 + n); for(int i = 1; i <= n; ++i) { position[boy[i].i] = i; } for(int i = 1; i <= n; ++i) { printf("%d ",position[girl[i].i]); } printf("\n"); for(int i = 1; i <= n; ++i) { position[girl[i].i] = i; } for(int i = 1; i <= n; ++i) { printf("%d",position[boy[i].i]); } printf("\n"); } return 0; }
D：
D題框架和練習賽的差不多，只不過多了一個查詢，而這個查詢只需要遍歷陣列就可以，並不需要二分法，不過注意找到的時候記得break,不然會TLE，而且大家要熟悉scanf，printf的輸入輸出方式，不然會TLE。
參考程式碼：
#include <cstdio>
#include <cmath>
#include <algorithm>
#define epsilon 1e-6
struct student {
int id;
char name[20];
double grade;
bool operator < (student const & other) const {
if (fabs(grade - other.grade) < epsilon) {
return id < other.id;
}
return grade > other.grade;
}
};
student students[10050];
int main() {
int n, m;
while(scanf("%d", &n) == 1) {
for (int i = 0; i < n; ++i) {
student student1;
scanf("%s %d %lf", student1.name, &student1.id, &student1.grade);
students[i] = student1;
}
std::sort(students, students + n);
scanf("%d", &m);
for (int j = 0; j < m; ++j) {
int id;
scanf("%d", &id);
bool isFound = false;
for (int i = 0; i < n; ++i) {
if (id == students[i].id) {
isFound = true;
student student1 =students[i];
printf("%s %d %.2f%d\n", student1.name, student1.id, student1.grade, i + 1);
break;
}
}
if (!isFound) {
printf("Only god knowswhere he is.\n");
}
}
}
}E
遞迴。
找到遞迴關係，我們不妨令f(m,n)表示m個人進入n個教室有多少種進法，下面根據不同情況分類：
(1):當教室數為1的時候，只有一種情況，即所有人在一個教室。
(2):當學生數為1的時候，也只有一種情況，注意題目中說明，教室之間並無順序,所以不管這個學生去哪個教室，結果都算一個。
(3):當m<n時，因為此時最多隻能去m個教室（一個教室去一個），實際上就相當於m個學生去到m個教室裡一樣，也就是f(m,m);
(4):當m==n時,此時分兩種情況討論，一種是一個教室裡去一個，只是一種，第二種是，至少有一個教室裡沒有學生這就相當於是f(m,m-1);
(5):當m>n時，也分兩種情況討論，一種是至少有一個教室裡沒學生，這樣子就相當於f(m,n-1),第二種是，每個教室先去一個學生，剩下的m-n個學生再進入到n個教室裡去，即f(m-n,n);
綜上所述:
得到遞迴表示式：
f(m,n)=1 當 m=1或n=1；
f(m,n)=f(m,m) 當m<n;
f(m,n)=1+f(m,m-1) 當m=n;
f(m,n)=f(m-n,n)+f(m,n-1);
在遞迴的過程中採用記憶化搜尋可以減少不必要的時間，算過的東西就不要再算了。
詳情請看程式碼：
#include <cstdio>
#include <cstring>
int f[123][123];
int GzhIsSoHandsome(int m,int n)
{
if(f[m][n])//避免重複搜尋
return f[m][n];
else if(m==1||n==1)
{
f[m][n]=1;
return f[m][n];
}
else if(m<n)
{
f[m][n]=GzhIsSoHandsome(m,m);
return f[m][n];
}
else if(m==n)
{
f[m][n]=1+GzhIsSoHandsome(m,m-1);
return f[m][n];
}
else
{
f[m][n]=GzhIsSoHandsome(m-n,n)+GzhIsSoHandsome(m,n-1);
return f[m][n];
}
}
int main()
{
int t,m,n;
scanf("%d",&t);
while(t--)
{
memset(f,0,sizeof(f));
scanf("%d%d",&m,&n);
printf("%d\n",GzhIsSoHandsome(m,n));
}
return 0;
}F
<問題描述>
所謂蟲食算，就是原先的算式中有一部分被蟲子啃掉了，需要我們根據剩下的數字來判定被啃掉的字母。來看一個簡單的例子：
43#9865#045
+ 8468#6633
其中#號代表被蟲子啃掉的數字。根據算式，我們很容易判斷：第一行的兩個數字分別是5和3，第二行的數字是5。
現在，我們對問題做兩個限制：
首先，我們只考慮加法的蟲食算。這裡的加法是N進位制加法，算式中三個數都有N位，允許有前導的0。
其次，蟲子把所有的數都啃光了，我們只知道哪些數字是相同的，我們將相同的數字用相同的字母表示，不同的數字用不同的字母表示。如果這個算式是N進位制的，我們就取英文字母表午的前N個大寫字母來表示這個算式中的0到N-1這N個不同的數字：但是這N個字母並不一定順序地代表0到N-1)。輸入資料保證N個字母分別至少出現一次。
BADC
+ CRDA
DCCC
上面的算式是一個4進位制的算式。很顯然，我們只要讓ABCD分別代表0123，便可以讓這個式子成立了。你的任務是，對於給定的N進位制加法算式，求出N個不同的字母分別代表的數字，使得該加法算式成立。輸入資料保證有且僅有一組解，
- 輸入檔案
輸入檔案alpha.in包含4行。第一行有一個正整數N(N<=26)，後面的3行每行有一個由大寫字母組成的字串，分別代表兩個加數以及和。這3個字串左右兩端都沒有空格，從高位到低位，並且恰好有N位。
- 輸出檔案
輸出檔案alpha.out包含一行。在這一行中，應當包含唯一的那組解。解是這樣表示的：輸出N個數字，分別表示A，B，C……所代表的數字，相鄰的兩個數字用一個空格隔開，不能有多餘的空格。
- 樣例輸入
5
ABCED
BDACE
EBBAA
- 樣例輸出
1 0 3 4 2
- 資料規模
對於30％的資料，保證有N<＝10；
對於50％的資料，保證有N<＝15；
對於全部的資料，保證有N<=26。
<演算法分析>
經典的搜尋題。最單純的搜尋的時間複雜度為O(n!)，是會非常嚴重的超時的。計算機是很“笨”的，它不會思考，在盲目搜尋的過程中，很容易出現這種情況：
計算機在某一位搜尋出了一個算式1 + 1 = 3，並且繼續搜尋。
明顯，人眼很容易就看出這是不合法的，但計算機不會。於是，我們想到了第一個剪枝：每次搜尋的時候，從最後向前判斷是否有不合法的式子。
這一個剪枝非常簡單，但是效果卻非常的好。因為它剪去了很多不必要的搜尋。為了配合這一種剪枝更好的實行，搜尋順序的改變也成為大大提高程式效率的關鍵：從右往左，按照字母出現順序搜尋，有很大程度上提高了先剪掉廢枝的情況，使程式的效率得到大大的提高。
有了以上兩個剪枝，程式就已經可以通過大部分測試點了。但是有沒有更多的剪枝呢？答案是肯定的。
根據前面的剪枝，我們可以找到類似的幾個剪枝：
對於a + b = c的形式，假如：
A***?***
+ B*?**?**
C***???*
其中*代表已知，?代表未知。那麼，A + B與C的情況並不能直接確定。但是，假如(A + B) % N與(A + B + 1) % N都不等於C的話，那麼這個等式一定是不合法的。因為它只有進位和不進位的兩種情況。
同樣，我們在一個數組裡記錄了Used[i]表示一個數字有沒有用過，那麼，對於某一位A + B = C的等式，如果已經得到了兩個數，另一個數還待搜尋的時候，我們還可以根據這個加入一個剪枝：
例如A + ? = C的形式，
考慮不進位的情況，則?處為P1 =(C - A + N) % N
假如考慮進位的情況，則?處為P2 =(C - A - 1 + N) % N
假如P1、P2均被使用過，那麼這個搜尋一定是無效的，可以剪去。
有了以上的剪枝，就可以很輕鬆地通過所有的測試資料了。當然，還有很多值得思考的剪枝以及其他的思路，例如列舉進位、解方程（但是可能需要列舉）等，在這裡就不詳細討論了。
<程式碼清單>
#include <fstream>
#include <string>
using namespace std;
ifstream fin("alpha.in");
ofstream fout("alpha.out");
bool finish, hash[256], used[27];
int n, stk[27];
string a, b, c;
string word;
void init() {
fin>> n >> a >> b >> c;
finish= false;
}
void outsol() {
inti, ans[27];
for(i = 0; i < n; i ++)
ans[word[i]- 65] = stk[i];
fout<< ans[0];
for(i = 1; i < n; i ++)
fout<< " " << ans[i];
fout<< endl;
finish= true;
}
void addup(char ch) {
if(!hash[ch]) {
hash[ch]= true;
word= word + ch;
}
}
string change(string str, char x, char y) {
for(int i = 0; i < n; i ++)
if(str[i] == x)
str[i]= y;
returnstr;
}
void pre_doing() {
word= "";
memset(hash,0, sizeof(hash));
for(int i = n - 1; i >= 0; i --) {
addup(a[i]);addup(b[i]); addup(c[i]);
}
memset(used,0, sizeof(used));
}
bool bad() {
intp, g = 0;
for(int i = n - 1; i >= 0; i --) {
if(a[i] >= n || b[i] >= n || c[i] >= n) return false;
p= a[i] + b[i] + g;
if(p % n != c[i]) return true;
g= p / n;
p%= n;
}
returnfalse;
}
bool modcheck() {
inti, p, p1, p2, g = 0;
//a+ b = c, all know
for(i = n - 1; i >= 0; i --) {
if(a[i] >= n || b[i] >= n || c[i] >= n) continue;
p= (a[i] + b[i]) % n;
if(!(p == c[i] || (p + 1) % n == c[i])) return true;
}
//a+ ? = c
for(i = n - 1; i >= 0; i --) {
if(!(a[i] < n && c[i] < n && b[i] >= n)) continue;
p1= (c[i] - a[i] + n) % n;
p2= (p1 - 1) % n;
if(used[p1] && used[p2]) return true;
}
//?+ b = c
for(i = n - 1; i >= 0; i --) {
if(!(a[i] >= n && c[i] < n && b[i] < n)) continue;
p1= (c[i] - b[i] + n) % n;
p2= (p1 - 1) % n;
if(used[p1] && used[p2]) return true;
}
//a+ b = ?
for(i = n - 1; i >= 0; i --) {
if(!(a[i] < n && b[i] < n && c[i] >= n)) continue;
p1= (a[i] + b[i]) % n;
p2= (p1 + 1) % n;
if(used[p1] && used[p2]) return true;
}
returnfalse;
}
void dfs(int l) {
inti;
stringA, B, C;
if(finish) return;
if(bad()) return;
if(modcheck()) return;
if(l == n) {
outsol();
return;
}
for(i = n - 1; i >= 0; i --)
if(!used[i]) {
used[i]= true; A = a; B = b; C = c;
a= change(A, word[l], i);
b= change(B, word[l], i);
c= change(C, word[l], i);
stk[l]= i;
dfs(l+ 1);
used[i]= false; a = A; b = B; c = C;
}
}
int main() {
init();
pre_doing();
dfs(0);
return0;
}<小結>
搜尋題的框架往往不難找到，關鍵就是在搜尋的優化上，本文的主要篇幅也就是討論了幾種有效的優化。搜尋問題的優化更多的需要選手的經驗和思考、分析問題的能力，所以搜尋剪枝也是競賽中經久不衰的經典問題。