鍒頒簡(jiǎn)榪欓噷鎴戣繕鏄竴鐐規(guī)濊礬閮芥病鏈夛紝涓鐐歸兘涓嶇煡閬撴庝箞鎼滅儲(chǔ)銆傘傘?br /> 鎯充簡(jiǎn)1涓灝忔椂錛屾棤澶寸華錛岄棶榪囦簡(jiǎn)榪欓鐨勫悓瀛︼紝榪樻槸鏃犲ご緇傜湅瑙ｉ鎶ュ憡錛屼粬浠殑浠ｇ爜鍐欏緱澶墰浜?jiǎn)锛屽畬鍏ㄧ湅涓嶆噦锛屾棤澶淳l?br />涔熻涔熸槸鎴戝bfs鐞嗚В澶祬錛屾墠鐪嬩笉鎳備粬浠殑鎼滅儲(chǔ)浠ｇ爜銆傝屼笖錛屾垜榪炲彲浠ユ悳绱㈢殑鍦版柟閮芥病鏈夋壘鍒幫紝閮戒笉鐭ラ亾鎼滀粈涔堜簡(jiǎn)銆?br /> 鎯充簡(jiǎn)濂戒箙錛屾槰澶╁悆楗殑鏃跺欙紝緇堜簬鍙戠幇鍙互瀵逛綑鏁拌繘琛屾悳绱€?br /> 瀵逛簬浠繪剰鐨凬錛屽叾浣欐暟灝辨槸鑼冨洿鏄痆0, N -1]銆傝繖涓叾瀹炲氨鍙互浠ｈ〃鐘舵佷簡(jiǎn)錛屾垨鑰呬唬琛╞fs涓殑鐐逛簡(jiǎn)銆備粠褰撳墠浣欐暟杞Щ鍒板叾瀹?br />浣欐暟鐨勬槸MOD * K + A 鎴栬?MOD * K + B錛屽鏋滆杞Щ鍒板緱浣欐暟浠ュ墠娌¤鎼滆繃錛岄偅灝卞彲浠ヨ漿縐昏繃鍘匯傝繖涓垰濂藉氨鏄竴涓?br />浼樺寲浜?jiǎn)銆備篃鍙互鐪嬫垚鏄瓙闂?shù)簡(jiǎn)銆備絾鏄紝dfs瀹屽叏涓嶈銆傚垰寮濮嬬敤dfs錛岀粷瀵圭殑瓚呮椂銆?br /> 鐢╠fs涔熸槸鎴戝鎬濊礬鐞嗚В涓嶆繁錛屼莖騫歌涓鴻兘榪囥傘傘傚悗闈㈠彂鐜幫紝榪欓瀹屽叏鍜宐fs鍚誨悎銆俒0, N -1]鍒氬ソ浠ｈ〃N涓偣錛屾垜瑕侀氳繃
浠庡闈㈢殑涓涓偣錛屾渶鐭殑閬嶅巻鍒扮偣0錛屽彲浠fs鎴栬呮渶鐭礬綆楁硶銆傝繖棰樻垜瑙夊緱榪樻湁涓毦鐐瑰氨鏄繚瀛樼瓟妗堬紝鍥犱負(fù)絳旀鏈闀跨殑闀垮害
鍙兘鏄疦(N<=10000)錛屾墍浠ユ妸絳旀鐩存帴鏀懼埌鑺傜偣閲岄潰鑲畾涓嶈鐨勩備絾鏄紝鎴戣繕?shù)粩缁嗙湅杩嚱帡娉曞D銆傚洜姝ゆ兂鍒頒簡(jiǎn)鍙互鍒╃敤bfs
鎼滅儲(chǔ)鍑烘潵鐨勯偅棰楁爲(wèi)鎴栬呮渶鐭礬綆楁硶璺戝嚭鏉ョ殑閭ｉ鏍?wèi)锛屼粠鐩爣鑺傜倸w嗗簭瀵繪壘絳旀錛屾壘鍒板嚭鍙戣妭鐐逛箣鍚庯紝鍐嶆妸絳旀reverse涓涓嬪氨琛屼簡(jiǎn)銆?br /> 榪欓榪樺緱娉ㄦ剰0涓嶈兘鏄疦鐨勫嶆暟錛屾墍浠ユ敞鎰廱fs(0,i)榪欑鎯呭喌鐨勫鐞嗐?br />
浠ｇ爜濡備笅錛?br />
#include <stdio.h>
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;
const int MAX_N = 10010;
int nOut[MAX_N];
int nOLen;
int nAns[MAX_N];
int nALen;
bool bMod[MAX_N];
int nFather[MAX_N];
int nChoose[MAX_N];
int nN;
int nK;
bool bFind;
int Cmp(int* A, int nLA, int* B, int nLB)
{
if (nLA != nLB)
{
return nLA - nLB;
}
for (int i = 0; i < nLA; ++i)
{
if (A[i] != B[i])
{
return A[i] - B[i];
}
}
return 0;
}
void Bfs(int nA, int nB)
{
memset(bMod, false, sizeof(bMod));
queue<int> que;
que.push(0);
int nTemp;
bool bFirst = true;
bFind = false;
if (nA > nB)swap(nA, nB);
//printf("nA:%d, nB:%d\n", nA, nB);
while (!que.empty())
{
//printf("nMod:%d\n", que.front());
int nMod = que.front();
que.pop();
if (nMod == 0)
{
if (bFirst)bFirst = false;
else
{
bFind = true;
break;
}
}
nTemp = (nMod * nK + nA) % nN;
if (!(nMod == 0 && nA == 0) && !bMod[nTemp])
{
nFather[nTemp] = nMod;
nChoose[nTemp] = nA;
que.push(nTemp);
bMod[nTemp] = true;
//printf("nTemp:%d\n", nTemp);
}
if (nA == nB)continue;
nTemp = (nMod * nK + nB) % nN;
if (!bMod[nTemp])
{
nFather[nTemp] = nMod;
nChoose[nTemp] = nB;
que.push(nTemp);
bMod[nTemp] = true;
//printf("nTemp:%d\n", nTemp);
}
}
if (bFind)
{
int nF = 0;
nALen = 0;
do
{
nAns[nALen++] = nChoose[nF];
nF = nFather[nF];
} while (nF);
reverse(nAns, nAns + nALen);
}
}
int main()
{
while (scanf("%d%d", &nN, &nK) == 2)
{
bool bOk = false;
nOLen = 0;
for (int i = 1; i < nK; ++i)
{
Bfs(i, i);
if (bFind)
{
if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
{
nOLen = nALen;
memcpy(nOut, nAns, sizeof(int) * nALen);
}
bOk = true;
}
}
if (!bOk)
for (int i = 0; i < nK; ++i)
{
for (int j = i + 1; j < nK; ++j)
{
Bfs(i, j);
if (bFind)
{
if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
{
nOLen = nALen;
memcpy(nOut, nAns, sizeof(int) * nALen);
}
}
}
}
for (int k = 0; k < nOLen; ++k)
{
printf("%d", nOut[k]);
}
printf("\n");
}
return 0;
}
#include <string.h>
#include <queue>
#include <algorithm>
using namespace std;
const int MAX_N = 10010;
int nOut[MAX_N];
int nOLen;
int nAns[MAX_N];
int nALen;
bool bMod[MAX_N];
int nFather[MAX_N];
int nChoose[MAX_N];
int nN;
int nK;
bool bFind;
int Cmp(int* A, int nLA, int* B, int nLB)
{
if (nLA != nLB)
{
return nLA - nLB;
}
for (int i = 0; i < nLA; ++i)
{
if (A[i] != B[i])
{
return A[i] - B[i];
}
}
return 0;
}
void Bfs(int nA, int nB)
{
memset(bMod, false, sizeof(bMod));
queue<int> que;
que.push(0);
int nTemp;
bool bFirst = true;
bFind = false;
if (nA > nB)swap(nA, nB);
//printf("nA:%d, nB:%d\n", nA, nB);
while (!que.empty())
{
//printf("nMod:%d\n", que.front());
int nMod = que.front();
que.pop();
if (nMod == 0)
{
if (bFirst)bFirst = false;
else
{
bFind = true;
break;
}
}
nTemp = (nMod * nK + nA) % nN;
if (!(nMod == 0 && nA == 0) && !bMod[nTemp])
{
nFather[nTemp] = nMod;
nChoose[nTemp] = nA;
que.push(nTemp);
bMod[nTemp] = true;
//printf("nTemp:%d\n", nTemp);
}
if (nA == nB)continue;
nTemp = (nMod * nK + nB) % nN;
if (!bMod[nTemp])
{
nFather[nTemp] = nMod;
nChoose[nTemp] = nB;
que.push(nTemp);
bMod[nTemp] = true;
//printf("nTemp:%d\n", nTemp);
}
}
if (bFind)
{
int nF = 0;
nALen = 0;
do
{
nAns[nALen++] = nChoose[nF];
nF = nFather[nF];
} while (nF);
reverse(nAns, nAns + nALen);
}
}
int main()
{
while (scanf("%d%d", &nN, &nK) == 2)
{
bool bOk = false;
nOLen = 0;
for (int i = 1; i < nK; ++i)
{
Bfs(i, i);
if (bFind)
{
if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
{
nOLen = nALen;
memcpy(nOut, nAns, sizeof(int) * nALen);
}
bOk = true;
}
}
if (!bOk)
for (int i = 0; i < nK; ++i)
{
for (int j = i + 1; j < nK; ++j)
{
Bfs(i, j);
if (bFind)
{
if (nOLen == 0 || Cmp(nOut, nOLen, nAns, nALen) > 0)
{
nOLen = nALen;
memcpy(nOut, nAns, sizeof(int) * nALen);
}
}
}
}
for (int k = 0; k < nOLen; ++k)
{
printf("%d", nOut[k]);
}
printf("\n");
}
return 0;
}
]]>
30 15
..............................
..............................
...............*..............
...*****......****............
...*X***.....**X***...........
...*****....***X**............
...***X*.....****.............
...*****.......*..............
..............................
........***........******.....
.......**X****.....*X**X*.....
......*******......******.....
.....****X**.......*X**X*.....
........***........******.....
..............................
姣斿涓婇潰榪欎釜30 * 15鐨勫浘鐗囬噷闈紝涓鍏辨湁鍥涗釜鍖哄煙錛?浣滀負(fù)鍖哄煙鐨勫簳鑹詫紝鐒跺悗鏄眰鍖哄煙閲岄潰鏈夊灝戜釜X鐨勫潡銆傝繖涓鍗曠函dfs鐨勮瘽錛屽緢娌″姙娉曪紝鍥犱負(fù)鏃犳硶涓嬈℃ф妸榪炴帴鍦ㄤ竴璧風(fēng)殑X閮芥悳绱簡(jiǎn)銆傛瘮濡傦紝
5 5XXX*X
XXX*X
.....
X***X
XX***
鐨勬椂鍊欙紝dfs寰堟槑鏄懼氨浼?xì)鍑虹幇闂锛屽洜湄?fù)浼?xì)鍏埣浾d紑X鍧楋紝鍐嶆鍥炲埌X鍧楋紝璁℃暟灝變細(xì)鍑虹幇闂?shù)簡(jiǎn)銆傚洜姝ゅ彧鑳介亣鍒癤鐨勬椂鍊欙紝榪涜涓嬈fs錛屽皢涓庡叾鐩歌繛鎺ョ殑X鍏ㄩ儴鎼滅儲(chǔ)鎺夈傘傘傚茍涓旀壘鍒頒笌褰撳墠X鍧楃浉榪炴帴鐨勪竴涓?鐨勪綅緗紝濡傛灉鏈夎繖鏍風(fēng)殑浣嶇疆錛屽氨緇х畫(huà)榪涜dfs銆?/span>
浠ｇ爜濡備笅錛?br />
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
int nW, nH;
char szData[100][100];
bool bVisit[100][100];
int nNum;
int nDice[100];
int nAdd[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
bool IsPosOk(int i, int j)
{
return i >= 0 && i < nH && j >= 0 && j < nW;
}
struct POS
{
int nI;
int nJ;
};
bool Bfs(int& nI, int& nJ)
{
bool bRet = false;
queue<POS> qp;
POS pos = {nI, nJ};
int i = nI, j = nJ;
qp.push(pos);
while (qp.empty() == false)
{
POS head = qp.front();
qp.pop();
for (int m = 0; m < 4; ++m)
{
int nNextI = head.nI + nAdd[m][0];
int nNextJ = head.nJ + nAdd[m][1];
if (IsPosOk(nNextI, nNextJ) && bVisit[nNextI][nNextJ] == false)
{
if (szData[nNextI][nNextJ] == 'X')
{
bVisit[nNextI][nNextJ] = true;
POS pos = {nNextI, nNextJ};
qp.push(pos);
}
else if (szData[nNextI][nNextJ] == '*')
{
bRet = true;
nI = nNextI;// 榪欓噷鏄繑鍥炴柊鐨刣fs浣嶇疆
nJ = nNextJ;
}
}
}
}
return bRet;
}
void dfs(int i, int j, int nNum)
{
bVisit[i][j] = true;
if (szData[i][j] == 'X')
{
nDice[nNum]++;
bool bDfs = Bfs(i, j);//鎵╂暎鎺夊綋鍓嶈繛閫氱殑鎵鏈?X'
if (bDfs == false)
{
return;
}
else
{
dfs(i, j, nNum);
}
}
for (int m = 0; m < 4; ++m)
{
int nNextI = i + nAdd[m][0];
int nNextJ = j + nAdd[m][1];
if (IsPosOk(nNextI, nNextJ) && bVisit[nNextI][nNextJ] == false
&& szData[nNextI][nNextJ] != '.')
{
dfs(nNextI, nNextJ, nNum);
}
}
}
int main()
{
int nCases = 1;
while (scanf("%d%d", &nW, &nH), nW + nH)
{
for (int i = 0; i < nH; ++i)
{
scanf("%s", szData[i]);
}
memset(bVisit, false, sizeof(bVisit));
memset(nDice, 0, sizeof(nDice));
nNum = 0;
for (int i = 0; i < nH; ++i)
{
for (int j = 0; j < nW; ++j)
{
if (szData[i][j] == 'X' && bVisit[i][j] == false)
{
dfs(i, j, nNum);
nNum++;
}
}
}
sort(nDice, nDice + nNum);
printf("Throw %d\n", nCases++);
for (int i = 0; i < nNum; ++i)
{
printf("%d%s", nDice[i], i == nNum - 1 ? "\n" : " ");
}
printf("\n");
}
return 0;
}
#include <string.h>
#include <algorithm>
#include <queue>
using namespace std;
int nW, nH;
char szData[100][100];
bool bVisit[100][100];
int nNum;
int nDice[100];
int nAdd[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
bool IsPosOk(int i, int j)
{
return i >= 0 && i < nH && j >= 0 && j < nW;
}
struct POS
{
int nI;
int nJ;
};
bool Bfs(int& nI, int& nJ)
{
bool bRet = false;
queue<POS> qp;
POS pos = {nI, nJ};
int i = nI, j = nJ;
qp.push(pos);
while (qp.empty() == false)
{
POS head = qp.front();
qp.pop();
for (int m = 0; m < 4; ++m)
{
int nNextI = head.nI + nAdd[m][0];
int nNextJ = head.nJ + nAdd[m][1];
if (IsPosOk(nNextI, nNextJ) && bVisit[nNextI][nNextJ] == false)
{
if (szData[nNextI][nNextJ] == 'X')
{
bVisit[nNextI][nNextJ] = true;
POS pos = {nNextI, nNextJ};
qp.push(pos);
}
else if (szData[nNextI][nNextJ] == '*')
{
bRet = true;
nI = nNextI;// 榪欓噷鏄繑鍥炴柊鐨刣fs浣嶇疆
nJ = nNextJ;
}
}
}
}
return bRet;
}
void dfs(int i, int j, int nNum)
{
bVisit[i][j] = true;
if (szData[i][j] == 'X')
{
nDice[nNum]++;
bool bDfs = Bfs(i, j);//鎵╂暎鎺夊綋鍓嶈繛閫氱殑鎵鏈?X'
if (bDfs == false)
{
return;
}
else
{
dfs(i, j, nNum);
}
}
for (int m = 0; m < 4; ++m)
{
int nNextI = i + nAdd[m][0];
int nNextJ = j + nAdd[m][1];
if (IsPosOk(nNextI, nNextJ) && bVisit[nNextI][nNextJ] == false
&& szData[nNextI][nNextJ] != '.')
{
dfs(nNextI, nNextJ, nNum);
}
}
}
int main()
{
int nCases = 1;
while (scanf("%d%d", &nW, &nH), nW + nH)
{
for (int i = 0; i < nH; ++i)
{
scanf("%s", szData[i]);
}
memset(bVisit, false, sizeof(bVisit));
memset(nDice, 0, sizeof(nDice));
nNum = 0;
for (int i = 0; i < nH; ++i)
{
for (int j = 0; j < nW; ++j)
{
if (szData[i][j] == 'X' && bVisit[i][j] == false)
{
dfs(i, j, nNum);
nNum++;
}
}
}
sort(nDice, nDice + nNum);
printf("Throw %d\n", nCases++);
for (int i = 0; i < nNum; ++i)
{
printf("%d%s", nDice[i], i == nNum - 1 ? "\n" : " ");
}
printf("\n");
}
return 0;
}
]]>
鍑?#8217;\n'錛岃屼笖uvaoj涓嶈兘瀵硅繖涓崲琛屽垽PE錛屼竴鐩存槸WA錛屽疄鍦ㄦ槸璁╀漢宕╂簝銆?br />
#include <stdio.h>
#include <string.h>
#define MAX (256 + 10)
#define MAX_NUM (150)
char szLines[MAX_NUM][MAX];
char szAns[MAX];
struct SET
{
int nNum;
char szLines[MAX_NUM][MAX];
bool bUsed[MAX];
};
SET sets[MAX];
char szTmpOne[MAX];
char szTmpTwo[MAX];
int nAnsLen;
bool bFind;
void dfs(int nI, int nNum)
{
if (nNum == 0)
{
bFind = true;
}
else
{
for (int i = 0; i < sets[nI].nNum && !bFind; ++i)
{
for (int j = 0; j < sets[nAnsLen - nI].nNum && !bFind; ++j)
{
if (nI == nAnsLen - nI && i == j)
{
continue;
}
if (!sets[nI].bUsed[i] && !sets[nAnsLen - nI].bUsed[j])
{
strcpy(szTmpOne, sets[nI].szLines[i]);
strcat(szTmpOne, sets[nAnsLen - nI].szLines[j]);
strcpy(szTmpTwo, sets[nAnsLen - nI].szLines[j]);
strcat(szTmpTwo, sets[nI].szLines[i]);
//printf("%s\n", szAns);
if (strcmp(szTmpOne, szAns) == 0 || strcmp(szTmpTwo, szAns) == 0)
{
sets[nI].bUsed[i] = sets[nAnsLen - nI].bUsed[j] = true;
if (!bFind)
{
if (nI == nAnsLen - nI)
{
dfs(nI, nNum - 2);
}
else
{
dfs(nI, nNum - 1);
}
}
sets[nI].bUsed[i] = sets[nAnsLen - nI].bUsed[j] = false;
}
}
}
}
}
}
bool Find(int nI)
{
bFind = false;
for (int i = 0; i < sets[nI].nNum && !bFind; ++i)
{
for (int j = 0; j < sets[nAnsLen - nI].nNum && !bFind; ++j)
{
if (nI == nAnsLen - nI && i == j)
{
continue;
}
sets[nI].bUsed[i] = true;
sets[nAnsLen - nI].bUsed[j] = true;
strcpy(szAns, sets[nI].szLines[i]);
strcat(szAns, sets[nAnsLen - nI].szLines[j]);
if (nI == nAnsLen - nI)
{
dfs(nI, sets[nI].nNum - 2);
}
else
{
dfs(nI, sets[nI].nNum - 1);
}
if (bFind)
{
for (int k = nI + 1; k <= nAnsLen / 2; ++k)
{
bFind = false;
dfs(k, sets[k].nNum);
if (!bFind)
{
break;
}
}
if (bFind)
{
return true;
}
}
strcpy(szAns, sets[nAnsLen - nI].szLines[j]);
strcat(szAns, sets[nI].szLines[i]);
if (nI == nAnsLen - nI)
{
dfs(nI, sets[nI].nNum - 2);
}
else
{
dfs(nI, sets[nI].nNum - 1);
}
if (bFind)
{
for (int k = nI + 1; k <= nAnsLen / 2; ++k)
{
bFind = false;
dfs(k, sets[k].nNum);
if (!bFind)
{
break;
}
}
if (bFind)
{
return true;
}
}
sets[nI].bUsed[i] = false;
sets[nAnsLen - nI].bUsed[j] = false;
}
}
return false;
}
void Search()
{
for (int i = 0; i <= nAnsLen; ++i)
{
if (sets[i].nNum)
{
Find(i);
break;
}
}
}
int main()
{
int nCases;
#ifdef CSU_YX
freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
#endif
scanf("%d\n", &nCases);
int nNum = 0;
int nTotalLen = 0;
while (gets(szLines[nNum]), nCases)
{
if (szLines[nNum][0] == '\0' && nNum != 0)
{
nAnsLen = nTotalLen * 2 / nNum;
memset(szAns, 0, sizeof(szAns));
Search();
printf("%s\n\n", szAns);
memset(sets, 0, sizeof(sets));
memset(szLines, 0, sizeof(szLines));
nNum = 0;
nTotalLen = 0;
--nCases;
}
else if (szLines[nNum][0] != '\0')
{
int nLen = strlen(szLines[nNum]);
nTotalLen += nLen;
strcpy(sets[nLen].szLines[sets[nLen].nNum], szLines[nNum]);
++sets[nLen].nNum;
++nNum;
}
}
return 0;
}
#include <string.h>
#define MAX (256 + 10)
#define MAX_NUM (150)
char szLines[MAX_NUM][MAX];
char szAns[MAX];
struct SET
{
int nNum;
char szLines[MAX_NUM][MAX];
bool bUsed[MAX];
};
SET sets[MAX];
char szTmpOne[MAX];
char szTmpTwo[MAX];
int nAnsLen;
bool bFind;
void dfs(int nI, int nNum)
{
if (nNum == 0)
{
bFind = true;
}
else
{
for (int i = 0; i < sets[nI].nNum && !bFind; ++i)
{
for (int j = 0; j < sets[nAnsLen - nI].nNum && !bFind; ++j)
{
if (nI == nAnsLen - nI && i == j)
{
continue;
}
if (!sets[nI].bUsed[i] && !sets[nAnsLen - nI].bUsed[j])
{
strcpy(szTmpOne, sets[nI].szLines[i]);
strcat(szTmpOne, sets[nAnsLen - nI].szLines[j]);
strcpy(szTmpTwo, sets[nAnsLen - nI].szLines[j]);
strcat(szTmpTwo, sets[nI].szLines[i]);
//printf("%s\n", szAns);
if (strcmp(szTmpOne, szAns) == 0 || strcmp(szTmpTwo, szAns) == 0)
{
sets[nI].bUsed[i] = sets[nAnsLen - nI].bUsed[j] = true;
if (!bFind)
{
if (nI == nAnsLen - nI)
{
dfs(nI, nNum - 2);
}
else
{
dfs(nI, nNum - 1);
}
}
sets[nI].bUsed[i] = sets[nAnsLen - nI].bUsed[j] = false;
}
}
}
}
}
}
bool Find(int nI)
{
bFind = false;
for (int i = 0; i < sets[nI].nNum && !bFind; ++i)
{
for (int j = 0; j < sets[nAnsLen - nI].nNum && !bFind; ++j)
{
if (nI == nAnsLen - nI && i == j)
{
continue;
}
sets[nI].bUsed[i] = true;
sets[nAnsLen - nI].bUsed[j] = true;
strcpy(szAns, sets[nI].szLines[i]);
strcat(szAns, sets[nAnsLen - nI].szLines[j]);
if (nI == nAnsLen - nI)
{
dfs(nI, sets[nI].nNum - 2);
}
else
{
dfs(nI, sets[nI].nNum - 1);
}
if (bFind)
{
for (int k = nI + 1; k <= nAnsLen / 2; ++k)
{
bFind = false;
dfs(k, sets[k].nNum);
if (!bFind)
{
break;
}
}
if (bFind)
{
return true;
}
}
strcpy(szAns, sets[nAnsLen - nI].szLines[j]);
strcat(szAns, sets[nI].szLines[i]);
if (nI == nAnsLen - nI)
{
dfs(nI, sets[nI].nNum - 2);
}
else
{
dfs(nI, sets[nI].nNum - 1);
}
if (bFind)
{
for (int k = nI + 1; k <= nAnsLen / 2; ++k)
{
bFind = false;
dfs(k, sets[k].nNum);
if (!bFind)
{
break;
}
}
if (bFind)
{
return true;
}
}
sets[nI].bUsed[i] = false;
sets[nAnsLen - nI].bUsed[j] = false;
}
}
return false;
}
void Search()
{
for (int i = 0; i <= nAnsLen; ++i)
{
if (sets[i].nNum)
{
Find(i);
break;
}
}
}
int main()
{
int nCases;
#ifdef CSU_YX
freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
#endif
scanf("%d\n", &nCases);
int nNum = 0;
int nTotalLen = 0;
while (gets(szLines[nNum]), nCases)
{
if (szLines[nNum][0] == '\0' && nNum != 0)
{
nAnsLen = nTotalLen * 2 / nNum;
memset(szAns, 0, sizeof(szAns));
Search();
printf("%s\n\n", szAns);
memset(sets, 0, sizeof(sets));
memset(szLines, 0, sizeof(szLines));
nNum = 0;
nTotalLen = 0;
--nCases;
}
else if (szLines[nNum][0] != '\0')
{
int nLen = strlen(szLines[nNum]);
nTotalLen += nLen;
strcpy(sets[nLen].szLines[sets[nLen].nNum], szLines[nNum]);
++sets[nLen].nNum;
++nNum;
}
}
return 0;
}
]]>
杈撳叆:涓涓簭鍒梥,璇ュ簭鍒楅噷闈㈠彲鑳戒細(xì)鏈夊悓鏍風(fēng)殑瀛楃,涓嶄竴瀹氭湁搴?鍜?涓涓暣鏁発
杈撳嚭:璇ュ簭鍒楀線(xiàn)鍚庤綆楃k涓簭鍒?鎵鏈夊簭鍒楁槸浠ュ瓧鍏稿簭鎺掑簭鐨?br />
濡傛灉浼?xì)鏈夊簭鎼滅储鐨勭闉嬭嚜鐒惰岀劧鑳界珛鍒誨仛鍑烘潵絎竴涓鐩?鍙槸絎簩涓鐩湪s杈冮暱鐨勬儏鍐典笅,鍗撮渶瑕佺敤妯℃嫙鑰屼笉鏄悳绱?..
澶у閮界煡閬揝TL閲岄潰鏈変釜娉涘嚱妯＄増, prev_permutation鍜宯ext_permutation,鐢ㄦ硶涔熷緢綆鍗?瀹炵幇鐨勫氨鏄鐩?鐨勫姛鑳?..
浣嗘槸綆楁硶鏈濂藉緱闈犺嚜宸辨兂鍑烘潵,鑷繁鎯沖嚭鏉ョ殑鎵嶆槸鑷繁鐨?紕板埌鏂扮殑闂鎵嶈兘浜х敓鎬濇兂鐨勭伀鑺?..
搴熻瘽灝戣,棰樼洰1鐨勮В娉曞氨鏄繁鎼?涓嶈繃闇瑕佸姞涓婁竴涓猙ool鏁扮粍鏍囪鍜屼竴涓嚱鏁扮‘瀹氫笉鍚屽瓧絎︿箣闂寸殑澶у皬(鏈夊彲鑳借繖涓ぇ灝忚繕?shù)笉鏄疉scii鐮佸氨鑳藉喅瀹氱殑),
澶ц嚧鎻忚堪涓嬫悳绱㈣繃紼?姣斿杈撳叆搴忓垪鏄?2345,閭ｄ箞鎴戞悳绱㈢殑榪囩▼澶ц嚧鏄涓灞傛寜欏哄簭閫夊彇1-5,榪涘叆絎簩灞傜殑鏃跺欎篃鏄寜欏哄簭閫夊彇1-5,
浠ユ綾繪帹,浣嗘槸姣忎竴灞傞噷闈㈤兘鍙兘閫夊墠闈㈢殑灞傛娌℃湁閫夎繃鐨勬暟,鑰屼笖鍥犱負(fù)鏈夐噸澶嶅瓧絎?綆楁硶榪樺繀欏諱繚璇佹瘡涓灞傞噷闈㈡寜欏哄簭閫夊彇鐨勫瓧絎﹀繀欏繪槸鍗囧簭鐨?
鐔熸?zhèn)墮搴搴忔悳鐑?chǔ)鍜屽洖婧殑鍚屽,寰堣嚜鐒跺氨浼?xì)漶旂敓杩欐狅L(fēng)殑鎯蟲(chóng)硶...
POJ - 1256鐨勪唬鐮佸涓?
棰樼洰2鐨勮В娉曟槸妯℃嫙,鍔熻兘綾諱技涓嶴TL鐨勯偅2涓硾鍨嬫ā鐗堝嚱鏁?綆楁硶鐨勫ぇ鑷磋繃紼嬫槸鎯沖姙娉曚粠褰撳墠搴忓垪榪涘叆涓嬩竴涓垰濂芥瘮鍏跺ぇ鎴栬呭垰濂芥瘮鍏跺皬鐨勫簭鍒?..寰堣嚜鐒舵垜浠兂鍒拌鎶婂簭鍒楀悗闈㈠ぇ鐨勫瓧絎︿氦鍜屽墠闈㈠皬鐨勫瓧絎︿氦鎹㈠氨浼?xì)鋴慑簭鍒楀彉澶?涓轟簡(jiǎn)浣垮叾鍒氬ソ鍙樺ぇ,鍙互鎶婁氦鎹㈠悗鐨勫瓧絎︿粠浜ゆ崲浣嶇疆璧瘋嚦鏈鍚庨兘鎺掑簭涓涓?鐜板湪鐨勯棶棰樻槸鎴戜滑濡備綍閫夊彇2涓瓧絎︿氦鎹?..姝ｇ‘鐨勬兂娉曟槸,鎴戜滑浠庢渶鍚庨潰寮濮嬪線(xiàn)鍓嶉潰鐪?瀵繪壘涓涓渶闀跨殑閫掑搴忓垪,鎵懼埌涔嬪悗,鎴戜滑鍙渶瑕侀夊彇閫掑搴忓垪鍓嶉潰鐨勯偅涓瓧絎hBefore鍜岄掑搴忓垪閲岄潰鐨勪竴涓渶灝忕殑姣攃hBefore澶х殑瀛楃浜ゆ崲鍗沖彲...浜ゆ崲涔嬪悗,灝嗘柊鐨勯掑搴忓垪鎺掑簭涓涓嬪嵆鍙?..
涓轟粈涔堣繖鏍峰仛浜?鍥犱負(fù)浠庡悗寰(xiàn)鍓嶇湅鐨勯掑搴忓垪,鏄笉鑳戒氦鎹?涓瓧絎﹁褰撳墠搴忓垪鍙樺ぇ鐨?鎵浠ュ繀欏婚夊彇鏈闀塊掑搴忓垪鍓嶉潰鐨勯偅涓瓧絎︿氦鎹?..
POJ鐧劇粌 - 1833 鐨勪唬鐮佸涓?
杈撳嚭:璇ュ簭鍒楀線(xiàn)鍚庤綆楃k涓簭鍒?鎵鏈夊簭鍒楁槸浠ュ瓧鍏稿簭鎺掑簭鐨?br />
濡傛灉浼?xì)鏈夊簭鎼滅储鐨勭闉嬭嚜鐒惰岀劧鑳界珛鍒誨仛鍑烘潵絎竴涓鐩?鍙槸絎簩涓鐩湪s杈冮暱鐨勬儏鍐典笅,鍗撮渶瑕佺敤妯℃嫙鑰屼笉鏄悳绱?..
澶у閮界煡閬揝TL閲岄潰鏈変釜娉涘嚱妯＄増, prev_permutation鍜宯ext_permutation,鐢ㄦ硶涔熷緢綆鍗?瀹炵幇鐨勫氨鏄鐩?鐨勫姛鑳?..
浣嗘槸綆楁硶鏈濂藉緱闈犺嚜宸辨兂鍑烘潵,鑷繁鎯沖嚭鏉ョ殑鎵嶆槸鑷繁鐨?紕板埌鏂扮殑闂鎵嶈兘浜х敓鎬濇兂鐨勭伀鑺?..
搴熻瘽灝戣,棰樼洰1鐨勮В娉曞氨鏄繁鎼?涓嶈繃闇瑕佸姞涓婁竴涓猙ool鏁扮粍鏍囪鍜屼竴涓嚱鏁扮‘瀹氫笉鍚屽瓧絎︿箣闂寸殑澶у皬(鏈夊彲鑳借繖涓ぇ灝忚繕?shù)笉鏄疉scii鐮佸氨鑳藉喅瀹氱殑),
澶ц嚧鎻忚堪涓嬫悳绱㈣繃紼?姣斿杈撳叆搴忓垪鏄?2345,閭ｄ箞鎴戞悳绱㈢殑榪囩▼澶ц嚧鏄涓灞傛寜欏哄簭閫夊彇1-5,榪涘叆絎簩灞傜殑鏃跺欎篃鏄寜欏哄簭閫夊彇1-5,
浠ユ綾繪帹,浣嗘槸姣忎竴灞傞噷闈㈤兘鍙兘閫夊墠闈㈢殑灞傛娌℃湁閫夎繃鐨勬暟,鑰屼笖鍥犱負(fù)鏈夐噸澶嶅瓧絎?綆楁硶榪樺繀欏諱繚璇佹瘡涓灞傞噷闈㈡寜欏哄簭閫夊彇鐨勫瓧絎﹀繀欏繪槸鍗囧簭鐨?
鐔熸?zhèn)墮搴搴忔悳鐑?chǔ)鍜屽洖婧殑鍚屽,寰堣嚜鐒跺氨浼?xì)漶旂敓杩欐狅L(fēng)殑鎯蟲(chóng)硶...
POJ - 1256鐨勪唬鐮佸涓?
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <algorithm>
#define MAX (13 + 10)
using namespace std;
bool bUsed[MAX];
char szAns[MAX];
char szInput[MAX];
bool CmpChar(char chOne, char chTwo)
{
if (abs(chOne - chTwo) != 'a' - 'A')
{
return tolower(chOne) - tolower(chTwo) < 0;
}
return chOne - chTwo < 0;
}
bool Greater(char chOne, char chTwo)
{
if (abs(chOne - chTwo) != 'a' - 'A')
{
return tolower(chOne) - tolower(chTwo) > 0;
}
return chOne - chTwo > 0;
}
void Gen(int nDepth, int nLen)
{
if (nDepth == nLen)
{
szAns[nLen] = '\0';
printf("%s\n", szAns);
return;
}
char chLast = '\0';
for (int i = 0; i < nLen; ++i)
{
if (!bUsed[i] && Greater(szInput[i], chLast))
{
bUsed[i] = true;
szAns[nDepth] = szInput[i];
Gen(nDepth + 1, nLen);
bUsed[i] = false;
chLast = szInput[i];
}
}
}
int main()
{
int nCases;
scanf("%d", &nCases);
while (nCases--)
{
scanf("%s", szInput);
int nLen = strlen(szInput);
sort(szInput, szInput + nLen, CmpChar);
Gen(0, nLen);
}
return 0;
}
涓轟粈涔堣繖鏍峰仛浜?鍥犱負(fù)浠庡悗寰(xiàn)鍓嶇湅鐨勯掑搴忓垪,鏄笉鑳戒氦鎹?涓瓧絎﹁褰撳墠搴忓垪鍙樺ぇ鐨?鎵浠ュ繀欏婚夊彇鏈闀塊掑搴忓垪鍓嶉潰鐨勯偅涓瓧絎︿氦鎹?..
POJ鐧劇粌 - 1833 鐨勪唬鐮佸涓?
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAX (1024 + 10)
using namespace std;
int nInput[MAX];
void GetNext(int* nInput, int nLen)
{
int i = nLen - 2;
while (i >= 0)
{
if (nInput[i] >= nInput[i + 1])
{
--i;
}
else
{
int k = i + 1;
for (int j = nLen - 1; j > i; --j)
{
if (nInput[j] > nInput[i] && nInput[j] < nInput[k])
{
k = j;
}
}
swap(nInput[i], nInput[k]);
sort(nInput + i + 1, nInput + nLen);
return;
}
}
sort(nInput, nInput + nLen);
}
int main()
{
int nCases;
scanf("%d", &nCases);
while (nCases--)
{
int nLen;
int nK;
scanf("%d%d", &nLen, &nK);
for (int i = 0; i < nLen; ++i)
{
scanf("%d", &nInput[i]);
}
for (int i = 0; i < nK; ++i)
{
GetNext(nInput, nLen);
}
for (int i = 0; i < nLen; ++i)
{
printf("%d%s", nInput[i], i == nLen - 1 ? "\n" : " ");
}
}
return 0;
}
]]>
榪欎釜棰樺彲浠ョ敤浜屽垎瑙?铏界劧涔熸湁dp鐨勮В娉曘傚彲鑳界敤浜屽垎瑙ｈ繖涓?shù)笉鏄緢鏄庢?浣嗘槸紜疄鏄彲浠ョ殑銆傛渶澶х殑瑙ｅ氨鏄墍鏈夌殑媯嶅瓙闀?瑕佹眰鐨勬瀛愭暟,鏈灝忕殑瑙ｆ槸0,鐩存帴鍦ㄥ叾涓繘琛屼簩鍒嗗嵆鍙傝繖涓灞炰簬浜屽垎鍑烘渶澶ф弧瓚蟲(chóng)潯浠剁殑瑙ｇ殑鎯呭喌銆傝繖涓?shù)皋Z粈涔堣兘澶熶簩鍒嗕簡(jiǎn)銆傛垜鏄繖鏍鋒兂鐨勩傞鍏?瑙ｇ┖闂寸‘瀹炴槸鏈夊簭鐨勫惂,浠庢暟瀛?-鏁板瓧nSum/nK銆傚叾嬈?瀵逛簬浠繪剰涓涓浜庤繖涓寖鍥村唴鐨勬暟瀛?鍙湁婊¤凍鍜屾弧瓚抽鐩姹?縐嶆儏鍐?閭ｄ箞鍜屾垜浠簩鍒嗘暟瀛楁湁浠涔堝尯鍒簡(jiǎn),鎴戜滑浜屽垎涓涓湁搴忔暟緇?鐪嬮噷闈㈡湁娌℃湁鏌愪釜鏁板瓧,鏄笉鏄篃鍙鍒ゆ柇涓媙Mid婊¤凍鏄惁鏉′歡鏄惂銆傛墍浠?榪欎釜棰樻槸鍙互浜屽垎鐨勩備簩鍒嗙殑鏉′歡灝辨槸瑙ｇ┖闂存湁搴忕殑,鎴栬呭彲浠ユ柟渚垮湪瑙ｇ┖闂撮噷闈㈣煩璺冦傝屼笖榪欎釜棰樼殑浜屽垎榪橀渶瑕佺偣鎶宸?鍥犱負(fù)鏄煡鎵炬弧瓚蟲(chóng)潯浠剁殑鏈澶цВ銆?br />
浠ｇ爜:
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAX (10000 + 10)
using namespace std;
int nN, nK;
int nWoods[MAX];
bool IsAnsOk(int nAns)
{
if (nAns == 0)
{
return true;
}
else
{
int nTotal = 0;
for (int i = nN - 1; i >= 0; --i)
{
nTotal += nWoods[i] / nAns;
if (nTotal >= nK)
{
return true;
}
}
return false;
}
}
int SearchAns(int nMax)
{
int nBeg = 0, nEnd = nMax;
while (nBeg <= nEnd)
{
int nMid = (nBeg + nEnd) / 2;
if (IsAnsOk(nMid))
{
nBeg = nMid + 1;
}
else
{
nEnd = nMid - 1;
}
}
return nBeg - 1;
}
int main()
{
while (scanf("%d%d", &nN, &nK) == 2)
{
int nSum = 0;
for (int i = 0; i < nN; ++i)
{
scanf("%d", &nWoods[i]);
nSum += nWoods[i];
}
sort(nWoods, nWoods + nN);
int nMax = nSum / nK;
printf("%d\n", SearchAns(nMax));
}
return 0;
}
鎵浠?鍙槸鎶?=鎹㈡垚浜?jiǎn)IsAnsOk鍑芥暟璋冪敤鑰屽凡...鑰屼笖鐢變簬榪欐槸鏌ユ壘鏈澶цВ,榪斿洖鍊煎仛浜?jiǎn)涓嬪彉鍖栬屽凡...
浠旂粏鍒嗘瀽浜屽垎鐨勫啓娉?鎴戠殑鍙︿竴綃囨枃绔?鏍囬鏄叧浜庡瘑鐮佺殑涓涓В棰樻姤鍛?鏈夎鏄?,
鍏跺疄鍐欏嚭鏌ユ壘鏈澶цВ鍜屾渶灝忚В鐨勪簩鍒嗛兘涓嶆槸浠墮夯鐑?chǔ)鐨勪簨鎯?..
]]>
榪?/a>涓鐩彲浠ユ灇涓炬垨鑰呯洿鎺ユ毚鍔涖備絾鏄?榪欎箣鍓嶅繀欏誨紕鏄庣櫧絳旀鐨勮В絀洪棿銆傘傘備篃灝辨槸瑙ｅ彲鑳界殑鎯呭喌銆傘傘傚緢綆鍗?涓鍏辨湁9縐嶇Щ鍔ㄦ柟妗堛備篃寰堜簡(jiǎn)鐒剁殑鐭ラ亾瀵逛簬鏌愮鏂規(guī)浣跨敤N嬈＄殑鏁堟灉絳夊悓浜嶯%4鐨勬晥鏋?涔熷氨鏄鏌愮鏂規(guī)鍙彲鑳戒嬌鐢?,1,2,3嬈°傘傘備竴鍏辨湁9縐嶆柟妗?閭ｄ箞涓鍏卞氨鍙湁4^9縐嶅彲鑳界殑瑙ｃ傘傘傝繖涔堝皬鐨勮В絀洪棿,鏃犺鐢ㄤ粈涔堟柟娉曢兘涓嶄細(xì)瓚呮椂浜?jiǎn)銆傘傘傛毚鍔涘彲浠ユ墠鐢?閲嶅驚鐜?鎴栬呮繁鎼?褰撴椂瑙夊緱鍐?閲嶅驚鐜槸浠跺緢緋楃殑浜嬫儏,灝辨灉鏂繁鎼滀簡(jiǎn)銆傘傘?br />濡傛灉榪欓鎵嶇敤鏋氫婦鐨勬柟娉曠殑璇?鎬濊冩柟寮忚繕鏄偅鏍峰厛紜畾鍋囪瑙ｇ殑閮ㄥ垎鎯呭喌,閫氳繃宸茬粡鐭ラ亾鐨勮鍒欑‘瀹氳В鐨勫叾瀹冩儏鍐?鐒跺悗姹傚嚭榪欎釜瑙?鍒ゆ柇榪欎釜瑙ｆ槸鍚︽弧瓚抽鐩姹傘傘傘傛瘮濡?鎴戜滑鍙互鏋氫婦1,2,3鍙鋒柟妗堢殑鎯呭喌,鏍規(guī)嵁瑙勫垯紜畾鍏跺畠鏂規(guī)鐨勪嬌鐢ㄦ儏鍐?姹傚嚭鎵鏈夋柟妗堢殑浣跨敤鎯呭喌鍚?鍒ゆ柇鍋囪鐨勮В鏄惁婊¤凍瑕佹眰灝卞彲浠ヤ簡(jiǎn)...
鎴戞墠鐢ㄧ殑鏄痙fs+鍓灊,榪欎釜棰樼洰鍏跺疄棰樻剰鎴栬呰絳旀鏈夎,鍥犱負(fù)絳旀鏄悳绱㈡壘鍒扮涓涓В,鑰屼笉鏄墍璋撶殑鏈鐭簭鍒楃殑瑙?褰撶劧濡傛灉鏁版嵁浣垮緱2鑰呴兘鏄竴鏍風(fēng)殑璇?閭ｄ箞棰樻剰灝辨棤璇簡(jiǎn)...鎴戠殑浠ｇ爜鏄亣璁炬壘鍒扮殑絎竴涓氨鏄渶鐭簭鍒楃殑,榪欑鎯呭喌涓嬫墠鑳戒嬌鐢ㄥ壀鏋?鍥犱負(fù)鎵懼埌涓涓В鍚庡氨涓嶉渶瑕佺戶(hù)緇壘浜?..
浠ｇ爜濡備笅:
#include <stdio.h>
int nMinTimes;
int nPath[40];
bool bFind = false;
char* szMoves[10] =
{
NULL,
"ABDE",
"ABC",
"BCEF",
"ADG",
"BDEFH",
"CFI",
"DEGH",
"GHI",
"EFHI"
};
bool IsPosOK(int* nPos)
{
for (int i = 0; i < 9; ++i)
{
if (nPos[i])
{
return false;
}
}
return true;
}
void Move(int nChoose, int nTimes, int* nPos)
{
if (nTimes > 0)
{
char* pszStr = szMoves[nChoose];
while (*pszStr)
{
nPos[*pszStr - 'A'] = (nPos[*pszStr - 'A'] + nTimes) % 4;
++pszStr;
}
}
}
void MoveBack(int nChoose, int nTimes, int* nPos)
{
if (nTimes > 0)
{
char* pszStr = szMoves[nChoose];
while (*pszStr)
{
nPos[*pszStr - 'A'] = (nPos[*pszStr - 'A'] - nTimes + 4) % 4;
++pszStr;
}
}
}
void Cal(int nChoose, int* nPos, int* nUsed, int nUsedTimes)
{
if (nChoose == 10)
{
if (IsPosOK(nPos) && !bFind)
{
nMinTimes = nUsedTimes;
for (int i = 0; i < nMinTimes; ++i)
{
nPath[i] = nUsed[i];
}
bFind = true;
}
return;
}
for (int i = 0; i <= 3; ++i)
{
Move(nChoose, i, nPos);
for (int j = 0; j < i; ++j)//鏀懼叆i嬈＄殑nChoose
{
nUsed[nUsedTimes + j] = nChoose;
}
if (!bFind)
{
Cal(nChoose + 1, nPos, nUsed, nUsedTimes + i);
}
MoveBack(nChoose, i, nPos);
}
}
int main()
{
int nPos[9];
int nUsed[40];
for (int i = 0; i < 9; ++i)
{
scanf("%d", &nPos[i]);
}
Cal(1, nPos, nUsed, 0);
for (int i = 0; i < nMinTimes; ++i)
{
printf("%d", nPath[i]);
if (i != nMinTimes - 1)
{
putchar(' ');
}
else
{
putchar('\n');
}
}
return 0;
}
榪欓亾棰樺叾瀹炴垜wa浜?jiǎn)杩?0嬈?鍘熷洜灝辨槸Move鍜孧oveBack鍐欓敊浜?娌℃湁縐誨姩nTimes嬈?鑰屽墠闈竴鐩村啓鎴愪簡(jiǎn)1,鏄ㄦ櫄wa寰楀疄鍦ㄦ棤璇簡(jiǎn)...浠婂ぉ鏅氫笂媯(gè)鏌ユ墠紿佺劧鍙戠幇鐨?..
榪欏崐涓鏈堝仛浜?0閬撻?shù)?閮芥病鏈夋敼鍔ㄨ繖浣庣駭鐨刡ug涔?fàn)鎯?..瀹炲湪鏃犺...閫掑綊,鍥炴函,鍓灊閮藉啓涓婁簡(jiǎn)...鍞?..瀹炲湪鏃犺...榪樹(shù)笉濡傜洿鎺?閲嶅驚鐜?澶氱渷蹇?..鐪熶笉璇ユ瑙嗘煇縐嶆柟娉曠殑...
榪欓亾棰樺叾瀹炴垜wa浜?jiǎn)杩?0嬈?鍘熷洜灝辨槸Move鍜孧oveBack鍐欓敊浜?娌℃湁縐誨姩nTimes嬈?鑰屽墠闈竴鐩村啓鎴愪簡(jiǎn)1,鏄ㄦ櫄wa寰楀疄鍦ㄦ棤璇簡(jiǎn)...浠婂ぉ鏅氫笂媯(gè)鏌ユ墠紿佺劧鍙戠幇鐨?..
榪欏崐涓鏈堝仛浜?0閬撻?shù)?閮芥病鏈夋敼鍔ㄨ繖浣庣駭鐨刡ug涔?fàn)鎯?..瀹炲湪鏃犺...閫掑綊,鍥炴函,鍓灊閮藉啓涓婁簡(jiǎn)...鍞?..瀹炲湪鏃犺...榪樹(shù)笉濡傜洿鎺?閲嶅驚鐜?澶氱渷蹇?..鐪熶笉璇ユ瑙嗘煇縐嶆柟娉曠殑...
]]>
榪?/a>涔熸槸涓涓緢綆鍗曠殑棰樼洰,澶у涓鐪嬮兘鐭ラ亾鐢ㄤ粈涔堟柟娉曚簡(jiǎn),褰撶劧濡傛灉鏄煡鎵劇殑璇?欏哄簭鏌ユ壘鏄笉琛岀殑,
鏂規(guī)硶涓,鏄敤map,寤虹珛涓猰ap<string, string>鐨勫瓧鍏?娉ㄦ剰涓嶈鎯沖綋鐒剁敤map<char*, char*>,
閭ｆ牱寰楀姩鎬佸垎閰嶅唴瀛?鎴栬呰繕鏄厛寮涓ぇ鏁扮粍瀛樺ソ瀛楀吀,鍏剁粨鏋滆繕鏄嫻垂浜?jiǎn)鍐呭?..
鎺掑簭+浜屽垎涔熶笉閿欑殑,鍥犱負(fù)鏁版嵁閲忕‘瀹炲緢澶?鑰屼笖棰樼洰涔熷緩璁敤c鐨刬o杈撳叆,鎵浠ヨ繖鏍峰啀寤虹珛map<string, string>
涓棿榪樺緱杞崲涓涓?..
鎬諱箣鍋氳繖涓榪樻槸寰堥『鍒╃殑,灝眞a浜?jiǎn)涓嬈?鍘熷洜鏄?鍒嗗啓閿欎簡(jiǎn),鎴戜篃寰堜箙娌″湪oj涓婂啓2鍒嗕簡(jiǎn)...
浠ｇ爜濡備笅:
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAX_WORD_LEN 11
#define MAX_DICTION_ITEM (100000 + 10)
using std::sort;
struct Dictionary
{
char szWord[MAX_WORD_LEN];
char szEnglish[MAX_WORD_LEN];
};
Dictionary diction[MAX_DICTION_ITEM];
bool CmpDictionItem(Dictionary one, Dictionary two)
{
return strcmp(one.szWord, two.szWord) < 0;
}
int FindEnglish(char* pszWord, int nItemNum)
{
int nBeg = 0, nEnd = nItemNum - 1;
int nCmp = 0;
while (nBeg <= nEnd)
{
int nMid = (nBeg + nEnd) / 2;
nCmp = strcmp(pszWord, diction[nMid].szWord);
if (nCmp == 0)
{
return nMid;
}
else if (nCmp < 0)
{
nEnd = nMid - 1;
}
else
{
nBeg = nMid + 1;
}
}
return -1;
}
int main()
{
char szStr[30];
char szWord[MAX_WORD_LEN];
int nCount = 0;
int nAnsItem = 0;
while (fgets(szStr, 29, stdin), szStr[0] != '\n')
{
sscanf(szStr, "%s%s", diction[nCount].szEnglish, diction[nCount].szWord);
++nCount;
}
sort(diction, diction + nCount, CmpDictionItem);
while (scanf("%s", szWord) == 1)
{
if ((nAnsItem = FindEnglish(szWord, nCount)) != -1)
{
printf("%s\n", diction[nAnsItem].szEnglish);
}
else
{
printf("eh\n");
}
}
return 0;
}
鍏跺疄鎴戠殑涓昏鐩殑鏄負(fù)浜?jiǎn)鎸囧囖Z簩鍒嗙殑鍐欐硶,澶у鐪嬫垜鐨凢indEnglish鍑芥暟,浼犻掔殑鏄暟緇勭殑鍦板潃鍜屾暟緇勭殑闀垮害,
鐒跺悗鎴戝啓鍑芥暟浣撶殑鏃跺欑敤鐨勬槸[]鐨勫艦寮?灝辨槸涓嬬‘鐣?涓婄‘鐣?榪欐牱鏈閲嶈鐨勬槸闇瑕佽冭檻寰幆鐨勬潯浠舵槸<榪樻槸
<=,鍏跺疄榪欎篃寰堝ソ鍒ゆ柇,鍥犱負(fù)涓婄晫鍜屼笅鐣岄兘鑳藉鍙栧埌,鎵浠?鏄垚绔嬬殑...鑰屼笖淇敼right鐨勬椂鍊?蹇呴』灝唕ight = mid - 1,
鍘熷洜涔熸槸鍥犱負(fù)榪欐槸涓婄‘鐣?
浣嗘槸濡傛灉鏄笂涓嶇‘鐣屼簡(jiǎn),閭ｄ箞絳夊彿灝卞繀欏誨幓鎺?鑰屼笖right涔熷彧鑳戒慨鏀逛負(fù)mid,鍥犱負(fù)mid-1灝辨槸紜晫浜?鑰宮id鎵嶆槸涓婁笉紜晫...
鎯沖埌榪欎釜紼嬪害鐨勮瘽,浠ュ悗鍐欏彧鏈夊敮涓瑙ｄ簩鍒嗗氨搴旇涓嶄細(xì)鍑洪敊浜?..浣嗘槸鍐欐煡鎵炬弧瓚蟲(chóng)潯浠剁殑鏈澶ф垨鑰呮渶灝忚В鐨勪簩鍒嗚繕闇瑕佸叾瀹冩妧宸?..
#include <string.h>
#include <algorithm>
#define MAX_WORD_LEN 11
#define MAX_DICTION_ITEM (100000 + 10)
using std::sort;
struct Dictionary
{
char szWord[MAX_WORD_LEN];
char szEnglish[MAX_WORD_LEN];
};
Dictionary diction[MAX_DICTION_ITEM];
bool CmpDictionItem(Dictionary one, Dictionary two)
{
return strcmp(one.szWord, two.szWord) < 0;
}
int FindEnglish(char* pszWord, int nItemNum)
{
int nBeg = 0, nEnd = nItemNum - 1;
int nCmp = 0;
while (nBeg <= nEnd)
{
int nMid = (nBeg + nEnd) / 2;
nCmp = strcmp(pszWord, diction[nMid].szWord);
if (nCmp == 0)
{
return nMid;
}
else if (nCmp < 0)
{
nEnd = nMid - 1;
}
else
{
nBeg = nMid + 1;
}
}
return -1;
}
int main()
{
char szStr[30];
char szWord[MAX_WORD_LEN];
int nCount = 0;
int nAnsItem = 0;
while (fgets(szStr, 29, stdin), szStr[0] != '\n')
{
sscanf(szStr, "%s%s", diction[nCount].szEnglish, diction[nCount].szWord);
++nCount;
}
sort(diction, diction + nCount, CmpDictionItem);
while (scanf("%s", szWord) == 1)
{
if ((nAnsItem = FindEnglish(szWord, nCount)) != -1)
{
printf("%s\n", diction[nAnsItem].szEnglish);
}
else
{
printf("eh\n");
}
}
return 0;
}
鍏跺疄鎴戠殑涓昏鐩殑鏄負(fù)浜?jiǎn)鎸囧囖Z簩鍒嗙殑鍐欐硶,澶у鐪嬫垜鐨凢indEnglish鍑芥暟,浼犻掔殑鏄暟緇勭殑鍦板潃鍜屾暟緇勭殑闀垮害,
鐒跺悗鎴戝啓鍑芥暟浣撶殑鏃跺欑敤鐨勬槸[]鐨勫艦寮?灝辨槸涓嬬‘鐣?涓婄‘鐣?榪欐牱鏈閲嶈鐨勬槸闇瑕佽冭檻寰幆鐨勬潯浠舵槸<榪樻槸
<=,鍏跺疄榪欎篃寰堝ソ鍒ゆ柇,鍥犱負(fù)涓婄晫鍜屼笅鐣岄兘鑳藉鍙栧埌,鎵浠?鏄垚绔嬬殑...鑰屼笖淇敼right鐨勬椂鍊?蹇呴』灝唕ight = mid - 1,
鍘熷洜涔熸槸鍥犱負(fù)榪欐槸涓婄‘鐣?
浣嗘槸濡傛灉鏄笂涓嶇‘鐣屼簡(jiǎn),閭ｄ箞絳夊彿灝卞繀欏誨幓鎺?鑰屼笖right涔熷彧鑳戒慨鏀逛負(fù)mid,鍥犱負(fù)mid-1灝辨槸紜晫浜?鑰宮id鎵嶆槸涓婁笉紜晫...
鎯沖埌榪欎釜紼嬪害鐨勮瘽,浠ュ悗鍐欏彧鏈夊敮涓瑙ｄ簩鍒嗗氨搴旇涓嶄細(xì)鍑洪敊浜?..浣嗘槸鍐欐煡鎵炬弧瓚蟲(chóng)潯浠剁殑鏈澶ф垨鑰呮渶灝忚В鐨勪簩鍒嗚繕闇瑕佸叾瀹冩妧宸?..
]]>