Letter Game[USACO]

/*
ID: zhangyc1
LANG: C++
TASK: lgame
*/
#include <fstream>
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <queue>
using namespace std;

char strGiven[10], strDict[10];
int nSizeGiven = 0;
int arrWeight[26] = {2, 5, 4, 4, 1, 6, 5, 5, 1, 7, 6, 3, 5, 2, 3, 5, 7, 2, 1, 2, 4, 6, 6, 7, 5, 7};
int arrCountGiven[26], arrCountDict[26];
char dict[40000][10];
struct SRecord
{
int nScore;
char strRs[10];
};
SRecord sArrRecord[40000];
int nDictSize = 0, nRsSize = 0;
ofstream fileout("lgame.out");

int compare(const void* argv1, const void* argv2)
{
const SRecord* p1 = (const SRecord*)argv1;
const SRecord* p2 = (const SRecord*)argv2;
if (p1->nScore == p2->nScore)
{
return strcmp(p1->strRs, p2->strRs);
}
else
return p2->nScore - p1->nScore;
}

void prepairData()
{
ifstream filein("lgame.in");
filein.getline(strGiven, sizeof(strGiven));
filein.close();
memset(arrCountGiven, 0, sizeof(arrCountGiven));
int i = 0;
while (strGiven[i] != '\0')
{
arrCountGiven[strGiven[i] - 'a']++;
i++;
}
nSizeGiven = i;
ifstream fileDict("lgame.dict");
while (fileDict >> strDict && strDict[0] != '.')
{
memset(arrCountDict, 0, sizeof(arrCountDict));
int nSizeStrDict = strlen(strDict);
if (nSizeStrDict > nSizeGiven)
continue;
bool bValid = true;
for (i = 0; i < nSizeStrDict; i++)
{
if (arrCountGiven[strDict[i]-'a'] == 0)
{
bValid = false;
break;
}
arrCountDict[strDict[i]-'a']++;
if (arrCountDict[strDict[i]-'a'] > arrCountGiven[strDict[i]-'a'])
{
bValid = false;
break;
}
}
if (bValid)
{
strcpy(dict[nDictSize], strDict);
nDictSize++;
}
}
fileDict.close();
}

void process()
{
int nSum = 0;
for (int i = 0; i < nSizeGiven; i++)
{
nSum += arrWeight[strGiven[i] - 'a'];
}
int arrCountTemp1[26], arrCountTemp2[26];

for (int i = 0; i < nDictSize; i++)
{
memset(arrCountTemp1, 0, sizeof(arrCountTemp1));
int nSizeI = strlen(dict[i]);
int j = 0, nSumI = 0;
for (; j < nSizeI; j++)
{
arrCountTemp1[dict[i][j] - 'a']++;
nSumI += arrWeight[dict[i][j] - 'a'];
}
if (nSizeGiven == 6 && nSizeI == 3)
j = i;
else
j = 0;

if (nSizeGiven - nSizeI >= 3)
{
if (nSizeI > nSizeGiven / 2)
{
continue;
}

for (; j < nDictSize; j++)
{
int nSizeJ = strlen(dict[j]), nSumJ = 0;
if (nSizeJ + nSizeI > nSizeGiven || (nSizeJ == nSizeI && j < i))
{
continue;
}
memset(arrCountTemp2, 0, sizeof(arrCountTemp2));

for (int k = 0; k < nSizeJ; k++)
{
arrCountTemp2[dict[j][k] - 'a']++;
nSumJ += arrWeight[dict[j][k] - 'a'];
}
bool bMatch = true;
for (int k = 0; k < 26; k++)
{
if (arrCountTemp1[k] + arrCountTemp2[k] > arrCountGiven[k])
{
bMatch = false;
break;
}
}
if (bMatch)
{
sArrRecord[nRsSize].nScore = nSumI + nSumJ;
if (strcmp(dict[i], dict[j]) > 0)
{
strcpy(sArrRecord[nRsSize].strRs, dict[j]);
sArrRecord[nRsSize].strRs[nSizeJ] = ' ';
strcpy(sArrRecord[nRsSize].strRs + nSizeJ + 1, dict[i]);
}
else
{
strcpy(sArrRecord[nRsSize].strRs, dict[i]);
sArrRecord[nRsSize].strRs[nSizeI] = ' ';
strcpy(sArrRecord[nRsSize].strRs + nSizeI + 1, dict[j]);
}
nRsSize++;
}
}
}
sArrRecord[nRsSize].nScore = nSumI;
strcpy(sArrRecord[nRsSize].strRs, dict[i]);
nRsSize++;
}

qsort(sArrRecord, nRsSize, sizeof(SRecord), compare);

fileout << sArrRecord[0].nScore << endl;
fileout << sArrRecord[0].strRs << endl;
for (int i = 1; i < nRsSize && sArrRecord[i].nScore == sArrRecord[0].nScore; i++)
{
if (strcmp(sArrRecord[i].strRs, sArrRecord[0].strRs) == 0)
{
continue;
}
fileout << sArrRecord[i].strRs << endl;
}
}

int main(){
prepairData();
process();
fileout.close();
return 0;
}