還記得上次深信服筆試挺慘的，選擇題錯一堆是因為計算機系統基礎部紮實，程式設計題是因為沒有能夠除錯的IDE，寫的程式都沒跑過，但是編寫和思路都很快想出來。
  這次總體難度相對於上次降低了很多，由於我個人程式設計題發揮太垃圾了弄得一塌糊塗GG了，題型相對於上次題型算是改動挺大，不定向選擇+填空題+程式設計題，從畢業到現在都沒怎麼寫過演算法題，忙著補充理論基礎然後沒注重演算法題就栽跟頭了，之前做暢遊筆試信心滿滿覺得筆試難度大多不難，這次的演算法題比上次簡單很多，不過我還是GG了。
  經歷過這次筆試，對秋招感覺越來越沒有把握，有點小絕望，發現秋招群中有很多19屆學生比現在的我優秀太多了，後面沒機會校招筆試這些公司了，偷懶提前享福，現在都得為這些懶惰負責。
  面試是沒機會了，就來記下一些記得的題覺得該寫下來或者是沒有完成的題目

選擇題

  （下列序號並不是試卷原先的題號）
1、下面哪個訊號是由應用程式捕捉segment fault?
A、SIGSEGV
B、SIGFPE
C、SIGILL
D、SIGBUS
  這道題，我是依靠著寫多程序程式的印象，選的A，捕捉段錯誤，雖然選對了，而我自己記住的訊號也就幾個，B、C、D沒接觸過，所以來記錄一下。

發出訊號的原因很多，這裡按發出訊號的原因簡單分類，以瞭解各種訊號： 　　（1）
與程序終止相關的訊號。當程序退出，或者子程序終止時，發出這類訊號。 　　（2）
與程序例外事件相關的訊號。如程序越界，或企圖寫一個只讀的記憶體區域（如程式正文區），或執行一個特權指令及其他各種硬體錯誤。 　　（3）
與在系統呼叫期間遇到不可恢復條件相關的訊號。如執行系統呼叫exec時，原有資源已經釋放，而目前系統資源又已經耗盡。 　　（4）
與執行系統呼叫時遇到非預測錯誤條件相關的訊號。如執行一個並不存在的系統呼叫。 　　（5）
在使用者態下的程序發出的訊號。如程序呼叫系統呼叫kill向其他程序傳送訊號。 　　（6）
與終端互動相關的訊號。如使用者關閉一個終端，或按下break鍵等情況。 　　（7） 跟蹤程序執行的訊號。
　　Linux支援的訊號列表如下。很多訊號是與機器的體系結構相關的，首先列出的是POSIX.1中列出的訊號： 訊號 值 處理動作
發出訊號的原因

SIGFPE 8 C 浮點異常
SIGBUS 10,7,10 C 匯流排錯誤(錯誤的記憶體訪問)
SIGILL 4 C 非法指令
  可以看到SIGBUS和SIGSEGV似乎都是錯誤記憶體訪問的型別，而兩者的區別就在於，SIGBUS通常是未對齊的資料訪問所致，如：
（下面程式碼在windows下的signal處理一律都是SIGSEGV，即段錯誤）

char *p=(char*)0x00001111;
*p=1;

  本來上面程式碼就是非法地址賦值，就會被SIGSEGV捕獲，但是如果把char改為int**，就不一樣了，可以看下面的彙編程式碼，異常會在寫入p地址值的時候發生，在unix中，第一個是因為訪問非法地址而報錯，而第二個是因為在寫入P的時候，在取指標p的兩字位置(地址mod4)出錯，0x1111 mod 4 !=0，也就是位元組未對齊，就是SIGBUS （看別人的解釋，自己大概闡述的）。

char *p = (char*)0x00001111;
01142731 mov dword ptr [p],1111h 
*p = 17;
01142738 mov eax,dword ptr [p] 
0114273B mov byte ptr [eax],11h 

int *p = (int*)0x00001111;
00AD2731 mov dword ptr [p],1111h 
*p = 17;
00AD2738 mov eax,dword ptr [p] 
00AD273B mov dword ptr [eax],11h 

  
  
二、請選出儘可能不調整數列上順序而且演算法複雜度為O(NlogN)的穩定排序演算法。
A、歸併排序
B、快速排序
C、插入排序
D、選擇排序
  
  這道題，我沒看懂不調整數列上順序是什麼意思，如果按NlogN來選，A、B符合，但是如果順序很雜亂，是得調整很多次，也就是大的值在前面，而小的值在後面，就得不停的交換，所以我個人覺得可能A、B是正確答案。
  
  
三、（答案不明）

  這道題，我自己最後瞎選的C、D，現在好好想的話覺得應該A、B、C好像都對，暫時找不到答案，知道答案的童鞋可以回覆我一下，之前只是大概的瞭解hash的這幾種做法，但並沒有去實現以及深入瞭解，我這幾天也來補補hash的知識。
  
  

填空題

1、

  答案是3/1，這道題剛開始看的時候，我是有點懵的，畢竟好久沒計算了，概率論也是我的差項，算出來的時候感覺這概率好違和，還以為錯了=_=，哈哈…
  這個問題在百度百科上有，即：三門問題，我的解法是，算出他不能得到豪車的概率P(A)，用1-P(A)即可，而他不可能得到豪車的情況是，他第一次選的門就是正確的，第二次選絕對是錯誤的，因為有兩扇門，所以就是P(A)=2/6 * 2=2/3，則他能贏的機率是1/3。
  
  
2、

  這道題我寫錯了，因為我剛剛寫了程式跑了一下，答案是35，而我為什麼寫6呢，原因我把題目看錯了，認為A到B是在方塊上移動，而且就這樣數，我特麼還數錯了，現在才知道是在線上的點移動Orz，從數學的角度分析，我們可以看到從A到B，最短路徑要一共要經過7個交點，而且必定有3次向下，4次向右，即一共的步驟是7次，所以我們只要計算C7 4或者C7 3就可以，算出在有效次數中，向下或者向右的組合有多少種，就知道一共的數目了。

int findroute(int x, int y) {
	cout << x << "and " << y << endl;
	if (x < 0 || y < 0)
		return 0;
	if (x == 0 && y == 0) {
		return 1;
	}
	int ret = 0;
	ret+=findroute(x - 1, y);
	ret+=findroute(x, y - 1);

	return ret;
}

程式設計題

  個人覺得題目難度還是可以的，有些題目很簡單，有些題目還是需要動腦思考，主要是閱讀理解題目要求你做什麼，我把時間都糾結在第一道題以及其網頁後臺的除錯結果，導致後面的題沒有編寫，以及第一道題沒有能夠除錯成功…
  （2018.9.22更新程式碼以及程式設計題）
  （2018.9.23更新第三題的程式碼，看了題目很久才知道題目要我做什麼Orz）
  個人總結：在這筆試之後，我自己花時間重新完成了這幾道程式設計題，我能夠確認的是，如果當天我的狀態好一些，我能夠在我做題做到程式設計題僅剩的1個小時裡完成題目1、2，題目3我沒讀懂題目意思有點傷，題目4除非再給我40+分鐘，我才能夠解決，這就是缺乏演算法訓練，如果是參加ACM或者相關演算法競賽，這些題難度不大，但是對於沒有刷題訓練的童鞋，我個人覺得會需要很多時間去思考以及實現，就比如我Orz，光理解題目意思就花了很長時間…
  
1、
  由於沒截圖完整，在這裡補充一下題目大概意思吧，輸入的第一行是測試的數量，第二行是木板的數量，第三行的資料是每個木板的高度。（上圖也是我通過樣例的截圖，然而提交後顯示0%樣例通過…）
  木板的意思是，例如2 1 2，就是第一塊木板高為2，第二塊木板高為1，那麼兩者之間能夠儲存1平方米的水量，如果第三塊木板為2，那麼中間的木板被淹沒，則儲存的水量為4平方米。
  所以樣例輸入的木板數量3，高度2 1 3，得到的結果是4。
  圖片右上角顯示我還有10分鐘，我莫名其妙花了大概50分鐘在這道題，因為我一直在考慮用什麼方法去解決，遞迴還是依靠棧還是迭代算出來？所以後面的題我也只能翻一翻截個圖了，很久沒寫演算法題，怎麼去解決問題的思路亂套了，感覺必須得多刷些這樣得題才能夠去應戰，理解題目的意思，然後分析，再去實現，現在的這衰樣都是自己懶出來的。
  而我提交的程式碼存在的問題是，沒有考慮周全，只考慮了部分情況，不可能0%樣例通過，我自己測了測試用例是通過的，弄得我一直在想問題出在哪不捨得做後面的題，我自己能夠測通過得樣例，網頁上得樣例檢測也能通過，但是在編輯器頁面儲存除錯就顯示0%…
  我的做法：
  首先得知道有哪幾種情況出現，高度級別，矮、高、超高，而我自己分析主要分為這三種情況：
  1、高矮高。（高矮超高與其是同一情況）
  2、超高矮高。（我原先的程式碼忽略了這個情況，已經修改過來了）
  3、矮高矮。

  所以大概的思路就是，符合情況3，就直接累加當前木板與下一個木板的儲存值然後移動head與end，否則就遇到1、2情況，就把end指向下一個end，然後比較head和end，而mid負責記錄中間的木板數量值。
  head，mid，end，其中head和end就像指標，head指向當前木板，end指向後面的木板，而mid僅僅是一個計數器，sum用於儲存值。
  在校招群裡我看到有童鞋使用vector和stack之類的搭配，或者與我一樣使用遞迴，而他們好像是完美通過測試，然而我卻卡在門外，Orz，我自己的失誤的確很多…

程式碼：

//head，mid，end初始值因為0，0，1
void water(int *moodh,size_t moods,int head,int mid,int end,int &sum) {
	if (end == moods) 
		return;
//這裡原先是<符號，因為這個原因碰到情況1會計算錯誤，現在改成<=
	if (moodh[head] <= moodh[end]) {
		sum += mid * moodh[head] + moodh[head];
		mid = 0;
		water(moodh, moods, end,mid, end + 1,sum);
	}
	else {
	//我原先編寫的沒有if(end-head!=1)這段，忘了情況2，現在補充的
		if (end - head != 1) {
			int val = moodh[head] > moodh[end] ? moodh[end] : moodh[head];
			sum += mid * val + val;
			water(moodh, moods, end, mid, end + 1, sum);
			return;
		}
		//以矮結尾，情況3
		if (end == moods - 1) {
			sum += moodh[end];
			return;
		}
		water(moodh, moods, head,mid+1, end + 1,sum);
	}	
}

int main()
{
	int c, size, sum = 0, cnt = 0;
	cin >> c;
	int *cmd = new int[c];
	while (cnt<c) {
		cin >> size;
		int *ary = new int[size];
		for (int i = 0; i < size; i++) {
			scanf_s("%d", &ary[i]);
		}
		water(ary, size, 0, 0, 1, sum);
		delete ary;
		cmd[cnt] = sum;
		cnt++;
		sum = 0;
	}
	for (int i = 0; i < c; i++) {
		cout << cmd[i];
		if (i != c - 1) {
			cout << endl;
		}
	}
	delete cmd；	
	return 0;
}

  
  
2、解二元一次方程
  題目過於囉嗦，要求輸入是，第一行輸入測試資料T組，然後第二行輸入處理資料。
  處理資料是 a1，b1，c1，a2，b2，c2，其中a1，b1，c1是一個方程的係數，a2，b2，c2是一組方程的係數，假設a是x的係數，b是y的係數，那麼我們輸出的結果就是求出x的值和y的值，無解的話輸出unknow，其中這些資料都是整數，非整數就是unknow。
  最簡單的解法就是消元法，或者用大學裡的代數知識，用行列式去計算，因為是二元一次方程組，只要把其中一個元化為0（即化成階梯型），然後用行列式去判斷其有解還是無解。
  因為我們要求的是整數解，所以就可以忽略很多情況了，只需要考慮是否能消元或者化為階梯矩陣，如果化的過程中無法整除，那麼就是無解。
  
  個人還是使用消元法，判斷也很簡單，我自己用了幾個簡單得例子測了程式碼沒問題。
程式碼：

void solution(int *ary,int &ret1,int &ret2) {
	if (ary == nullptr) {
		return;
	}
	int *p = ary;
	int *q = ary + 3;
	int cnt = 1, val1 = *p, val2 = *q;
	while (cnt < 4) {
		*p++ = (*p)*val2;
		*q++ = (*q)*val1;
		cnt++;
	}
	for (int i = 0; i < 3; i++) {
		ary[i + 3] = ary[i+3] - ary[i];
	}
	if (ary[5] % ary[4] != 0) {
		ret1 = -1;
		ret2 = -1;
	}
	else {
		ret2 = ary[5] / ary[4];
		ret1 = (ary[2] - ary[1] * ret2) / ary[0];
	}
} 
int main()
{
	int ary[] = { 3,4,7,5,6,11 };
	int s1,s2;
	solution(ary, s1, s2);
	if (s1 == -1) {
		cout << "unknow unknow" << endl;
	}
	else {
		cout << s1 << " " << s2 << endl;
	}
	return 0;
}

  
  
  
3、求最小子序列合最小值
  
  
  這道題目前面的話把我看迷糊了，有用的話也就是我打箭頭的那裡，也就是求一個序列的子序列合最小值。
  這道題解決方式的話，我是使用類似於第四道程式設計題的解法，即窮舉，畢竟要找到所有的最小值或者最大值，你就得把結果都計算出來。

int findMinSum(int *ary,int start,int size) {
	if (start == size - 1) {
		return ary[start];
	}
	int minv = 0, sum = 0;
	for (int i = start; i < size; i++) {
		sum += ary[i];
		if (minv > sum) {
			minv = sum;
		}
	}
	minv = min(findMinSum(ary, start + 1, size), minv);
	return minv;
}
int main()
{
	int ary[] = { 2,-3,-4,1,-3,2,-1 };
	int ret=findMinSum(ary, 0, 7);
	cout << ret;
	return 0;
}

  
4、求最優值
  這道題的題目前面的廢話太多，就截圖該部分。


  很簡單的一道題目，就是介紹的字很多，大概意思就是求出不同列不同行的組合最大值。
  原先以為簡單而打算找個時間隨便寫個程式碼就能執行，現在有點打臉了，寫的時候眉頭一皺發現事情並沒想得那麼簡單，實際寫還是有點複雜的，主要問題是如果列數一多，怎麼去判斷是否同行同列，也就涉及到了該用怎樣的資料結構去儲存點的資訊。
  而完成這道題，我花了近一小時的時間，包括我思考怎樣去求解以及實現與除錯，我第一時間所想到的求解方法就是寫各種迴圈，巢狀進去從而達到窮舉，然後發現需要儲存許多狀態值，如是否同行同列，然後又儲存各種狀態的求和值，就感覺我自己用一般的迴圈是行不通的（在寫這一般的迴圈巢狀花了挺長時間Orz），於是就想到了借用stack，達到儲存值，於是就有了下面的程式碼。

  情況的話分為兩種：
  1、人數=<崗位
  2、人數>崗位
  情況這樣分是根據我自己的寫的演算法設計的，第一種情況，我是通過崗位去遍歷人數，從而儲存不同搭配得到的值，而第二種情況還使用第一種情況的話，會存在有一些人數與崗位搭配沒算進去，這是和我寫的程式相關的，所以第二種情況就是使用人數去遍歷崗位，具體實現如下。

程式碼：

struct Node {
	int raw;
	int col;
	int val;
	Node(int x = 0, int y = 0,int v=0) :raw(x), col(y) ,val(v){};
};

int findMaxSum(int **ary,int row,int col) {
	int max = -1, val = 0, cnt = 0;
	//記錄崗位是否被佔用
	int *statcol = new int[col]();
	int realr, realc;
	//pary是用於判斷是哪種情況的陣列
	int **pary;
	stack<Node*> mlist;
	//如果row>col，將矩陣轉置
	if (row > col) {
		realr = col, realc = row;
		pary = new int*[col];
		for (int i = 0; i < col; i++) {
			pary[i] = new int[row];
		}
		for (int i = 0; i < col; i++) {
			for (int j = 0; j < row; j++) {
				pary[i][j] = ary[j][i];
			}
		}
		for (int i = 0; i < row; i++) {
			delete[] ary[i];
		}
		delete[]ary;
	}
	else {
		realr = row, realc = col;
		pary = ary;
	}
	//初始化
	for (int i = 0; i < realc; i++) {
		int flag = realc - 1 - i;
		auto tmp = new Node(0,flag,pary[0][flag]);
		mlist.push(tmp);
	}
	while (!mlist.empty()) {
		auto cur = mlist.top();
		auto curraw = cur->raw, curcol = cur->col, curval = cur->val;
		mlist.pop();
		//重置statcol
		if (curraw == 0) {
			for (int i = 0; i < realc; i++)
				statcol[i] = 0;
		}
		if (curraw == realr - 1) {
			max = curval > max ? curval : max;
			statcol[curcol] = 0;
			continue;
		}
		if (statcol[curcol] == 1) {
			continue;
		}
		statcol[curcol] = 1;
		for (int i = 0; i < realc; i++) {
			int flag = realc - 1 - i;
			if (statcol[flag] != 1) {
				auto tmp = new Node(curraw + 1, flag, curval + pary[curraw + 1][flag]);
				mlist.push(tmp);
			}
		}
		delete cur;
	}
	for (int i = 0; i < realr; i++) {
		delete[] pary[i];
	}
	delete[]pary;
	return max;
}
int main()
{
//測試用例是3行，2列
	const int r = 3;
	const int c = 2;
	//ary在findMaxSum中delete
	int **ary = new int*[r];
	for (int i = 0; i < r; i++) {
		ary[i] = new int[c];
	}
	for (int i = 0; i < r; i++) {
		for (int j = 0; j < c; j++) {
			cin >> ary[i][j];
		}
	}
	int ret = findMaxSum(ary, r, c);
	cout << ret;
	return 0;
}

  
結果圖：