int main(void){
char in[SIZE],out[SIZE],c;
int i=0;
while((c=getchar()) != '\n')
in[i++] = c;//input an char array including space
in[i] = '\0';
expend(in,out);
//printf("%s",in);
printf("%s",out);
system("pause");
return 0;
}
LL solve() {
init();
for(int i = 0; i < n; ++i) {
expend(str[i] - 'a');
end[i] = last;
}
for(int i = 0; i < n; ++i) {
for(State *p = end[i]; p && p->first == -1; p = p->par)
p->first = i;
}
State *p = root;
for(int i = 0, l = 0; i < n; ++i) {
int w = str[i] - 'a';
while(!p->go[w]) {
p = p->par;
l = p->val;
}
p = p->go[w];
l++;
while(p->first > i - l) {
l--;
if(p->par->val == l)
p = p->par;
}
match[i] = l;
}
l = r = 0;
for(int i = 0; i < n; ++i) {
dp[i] = cost[str[i] - 'a'];
if(i > 0) dp[i] += dp[i - 1];
while(l != r && que[l] < i - match[i])
++l;
if(l < r) {
int j = que[l];
dp[i] = std::min(dp[i], dp[j] + LL(i - j) * A + 2 * B);
}
while(l != r && getval(que[r - 1]) >= getval(i))
--r;
que[r++] = i;
}
return dp[n - 1];
}
int IndexFieldInc::addTerm(uint64_t termSign, uint32_t docId, uint8_t firstOcc)
{
// 检查并删除idx_dict中超时的buffer空间
idx_dict_free_oldblock(_bitmapDict);
idx_dict_free_oldblock(_invertedDict);
if(unlikely((_fullDocNum + 8*_maxIncBitmapSize) <= docId))
{
TWARN("inc reach max doc count limit!");
return KS_SUCCESS;
}
if(_bitmapDict)
{
idict_node_t* pNodeBitmap = idx_dict_find(_bitmapDict, termSign);
if(pNodeBitmap)
{
bitmap_idx1_unit_t* pIncBitmap = (bitmap_idx1_unit_t*)pNodeBitmap;
uint64_t * pBitmap = (uint64_t*)(_pIncMemManager->offset2Addr(pIncBitmap->pos));
pBitmap -= _fullDocNum / 64;
pBitmap[docId / 64] |= bit_mask_tab[docId % 64];
pIncBitmap->doc_count++;
pIncBitmap->max_docId = docId;
if (_bitmapDict->syncMgr) {
IndexFieldSyncManager * pSyncMgr = (IndexFieldSyncManager *) _bitmapDict->syncMgr;
pSyncMgr->putIdxDictNode(pNodeBitmap);
pSyncMgr->syncToDisk();
}
}
}
inc_idx2_header_t* head = NULL;
// 确定新的2级索引单元的写入位置
idict_node_t* pNode = idx_dict_find(_invertedDict, termSign);
if(pNode == NULL) { // 没有这个token, 申请一个新的block
int32_t pageSize = getPageSize(0, 0);
uint32_t off = 0;
if(_pIncMemManager->makeNewPage(pageSize, off) < 0) {
return KS_ENOMEM;
}
char* buf = _pIncMemManager->offset2Addr(off);
head = (inc_idx2_header_t*)buf;
head->pageSize = _pIncMemManager->size(off);
head->endOff = sizeof(inc_idx2_header_t);
head->zipFlag = 0;
idict_node_t node = {0L, 0, 0, 0, 0};
node.sign = termSign;
((inc_idx1_unit_t*)&node)->pos = off;
if (0 != idx_dict_add(_invertedDict, &node)) {
TWARN("add token %lu to idx1 dict failed", node.sign);
return KS_EFAILED;
}
pNode = idx_dict_find(_invertedDict, termSign);
}
if(NULL == pNode) {
TWARN("add token %lu to idx1 dict failed", termSign);
return KS_EFAILED;
}
// 获取头信息，定位到空白内存处
inc_idx1_unit_t* pind1 = (inc_idx1_unit_t*)pNode;
char* begin = _pIncMemManager->offset2Addr(pind1->pos);
head = (inc_idx2_header_t*)begin;
char* end = begin + head->pageSize;
// begin = _pIncMemManager->offset2Addr(head->endOff);
begin += head->endOff;
uint32_t docCount = getDocNumByEndOff(head->endOff, head->zipFlag);
if (unlikely(docCount != pind1->doc_count)) {
TWARN("doc_count[%u] in idx1 mismatch idx2_header[%u]!", pind1->doc_count, docCount);
pind1->doc_count = docCount;
}
/*
if (head->zipFlag == 1) {
idx2_zip_header_t *zipHeader = (idx2_zip_header_t*)(head + 1);
idx2_zip_skip_unit_t *skip = (idx2_zip_skip_unit_t*)(zipHeader + 1);
if (skip[zipHeader->block_num - 1].off > (docCount - 1)) {
TWARN("reduce block_num!");
zipHeader->block_num--;
skip[zipHeader->block_num].off = docCount;
skip[zipHeader->block_num].doc_id_base = IDX_GET_BASE(INVALID_DOCID);
}
}
*/
// 扩容
uint32_t len = 0;
if(head->zipFlag == 1)
{
len = (_maxOccNum > 0) ? sizeof(idx2_zip_list_unit_t) : sizeof(uint16_t);
if(begin + (len<<1) > end)
{
int32_t ret = expend(head, pind1, begin, end);
if(ret != KS_SUCCESS)
return ret;
}
}
else
{
len = (_maxOccNum > 0) ? sizeof(idx2_nzip_unit_t) : sizeof(uint32_t);
if(begin + (len<<1) > end)
{
int32_t ret = expend(head, pind1, begin, end);
if(ret != KS_SUCCESS)
return ret;
}
}
// 增加一篇文档
if(head->zipFlag == 1)
{
uint16_t base = IDX_GET_BASE(docId);
uint16_t diff = IDX_GET_DIFF(docId);
idx2_zip_header_t *zipHeader = (idx2_zip_header_t*)(head + 1);
idx2_zip_skip_unit_t *skip = (idx2_zip_skip_unit_t*)(zipHeader + 1);
if(_maxOccNum == 0)
{
*(uint16_t*)(begin+sizeof(uint16_t)) = IDX_GET_DIFF(INVALID_DOCID);;
*(uint16_t*)begin = diff;
begin += sizeof(uint16_t);
zipHeader->doc_list_len += sizeof(uint16_t);
}
else
{
((idx2_zip_list_unit_t*)(begin+sizeof(idx2_zip_list_unit_t)))->doc_id_diff = IDX_GET_DIFF(INVALID_DOCID);
((idx2_zip_list_unit_t*)begin)->doc_id_diff = diff;
((idx2_zip_list_unit_t*)begin)->occ = firstOcc;
begin += sizeof(idx2_zip_list_unit_t);
zipHeader->doc_list_len += sizeof(idx2_zip_list_unit_t);
}
if(zipHeader->block_num == 0 || base > skip[zipHeader->block_num-1].doc_id_base)
{
if(unlikely(zipHeader->block_num == _maxIncSkipCnt))
{
TWARN("inc reach max doc count limit!");
return KS_SUCCESS;
}
skip[zipHeader->block_num+1].doc_id_base = IDX_GET_BASE(INVALID_DOCID);
skip[zipHeader->block_num+1].off = pind1->doc_count + 1;
skip[zipHeader->block_num].doc_id_base = base;
skip[zipHeader->block_num].off = pind1->doc_count;
zipHeader->block_num++;
}
else
{
skip[zipHeader->block_num].off = pind1->doc_count + 1;
}
pind1->doc_count++;
}
else
{
if(_maxOccNum == 0)
{
*(uint32_t*)(begin+sizeof(uint32_t)) = INVALID_DOCID;
*(uint32_t*)begin = docId;
pind1->doc_count++;
begin += sizeof(uint32_t);
}
else
{
((idx2_nzip_unit_t*)(begin+sizeof(idx2_nzip_unit_t)))->doc_id = INVALID_DOCID;
((idx2_nzip_unit_t*)begin)->doc_id = docId;
((idx2_nzip_unit_t*)begin)->occ = firstOcc;
pind1->doc_count++;
begin += sizeof(idx2_nzip_unit_t);
}
}
char* p1 = _pIncMemManager->offset2Addr(pind1->pos);
head->endOff = begin - p1;
if (_invertedDict->syncMgr)
{
IndexFieldSyncManager * pSyncMgr = (IndexFieldSyncManager *) _invertedDict->syncMgr;
pSyncMgr->putIdxDictNode(pNode);
pSyncMgr->syncToDisk();
}
return 1;
}
