poj-1200

最新推荐文章于 2019-03-29 21:59:16 发布

原创最新推荐文章于 2019-03-29 21:59:16 发布 · 573 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#poj

POJ 专栏收录该内容

233 篇文章

订阅专栏

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_SUBSTRING_NUM 1600000
#define BIG_PRIME 1000007
#define MAX_N 25
char baseString[3000000];

struct NodeInfo{
    char val[MAX_N];
    int next;
};

typedef struct NodeInfo NodeInfo;

int bucket[BIG_PRIME];
NodeInfo storage[MAX_SUBSTRING_NUM];
int storageFreeIndex;

int hash(char * str, int length) {
    long long add = 0;
    for (long i = 0; i < length; i++) {
        add += str[i] * str[i];
    }
    return add%BIG_PRIME;
}

int ELFhash(char *key, int M)
{
    unsigned int h=0;
    while(*key)
    {
        h=(h<<4)+ *key++;
        unsigned int g= h&0xF0000000;
        if(g) h^=g>>24;
        h&=~g;
    }
    return h%M;
}

// char checkSubString(long begin, long end, char * baseString) {
//     char tmpArray[MAX_N] = {0};
//     long length = end - begin + 1;
//     memcpy(tmpArray, baseString + begin, length);
//     // printf("checkSubString %s\n", tmpArray);
//     int hval = hash(tmpArray, length);
//     NodeInfo * current = hashMap[hval];
//     while(current) {
//         if (!strcmp(current->val, tmpArray)) {
//             return 0;
//         }
//         current = current->next;
//     }
//     NodeInfo * prev = hashMap[hval];
//     NodeInfo * newNode = (NodeInfo *)malloc(sizeof(NodeInfo));
//     memset(newNode, 0, sizeof(NodeInfo));
//     memcpy(newNode->val, tmpArray, length);
//     hashMap[hval] = newNode;
//     hashMap[hval]->next = prev;
//     return 1;
// }

char checkSubStringStatic(long begin, long end, char * baseString) {
    char tmpArray[MAX_N] = {0};
    long length = end - begin + 1;
    memcpy(tmpArray, baseString + begin, length);
    int hval = ELFhash(tmpArray, BIG_PRIME);
    // printf("checkSubString %s %d\n", tmpArray, hval);
    if (bucket[hval]) {
        int currId = bucket[hval];
        while(currId) {
            // printf("currId %d %s %s\n", currId, tmpArray, storage[currId].val);
            if (!strcmp(tmpArray, storage[currId].val)) {
                return 0;
            }
            currId = storage[currId].next;
        }
        int prev = bucket[hval];
        bucket[hval] = storageFreeIndex++;
        memset(&(storage[bucket[hval]]), 0, sizeof(NodeInfo));
        storage[bucket[hval]].next = prev;
        memcpy(storage[bucket[hval]].val, tmpArray, length);
        return 1;
    } else {
        // printf("first %d %s\n", storageFreeIndex, tmpArray);
        bucket[hval] = storageFreeIndex++;
        memset(&(storage[bucket[hval]]), 0, sizeof(NodeInfo));
        storage[bucket[hval]].next = 0;
        memcpy(storage[bucket[hval]].val, tmpArray, length);
        return 1;
    }
}

long long getCombineNum(int N, int NC, char * baseString) {
    long length = strlen(baseString);
    long long combine_num = 0;
    if (length < N) {
        return 0;
    }
    // long long max_combine_num = 1;
    // for (int i = 1; i <= N; i++) {
    //     max_combine_num *= NC;
    // }

    for (long i = 0; i <= (length - 1) - N + 1; i++) {
        long end = i + N -1;
        combine_num += checkSubStringStatic(i, end, baseString);
        // if (combine_num >= max_combine_num) {
        //     return combine_num;
        // }
    }
    return combine_num;
}
int main() {
    int N = 0;
    int NC = 0;
    // while(scanf("%d %d", &N, &NC) != EOF) {
        scanf("%d %d", &N, &NC);
        scanf("%s", baseString);
        memset(storage, 0, sizeof(storage));
        memset(bucket, 0, sizeof(bucket));
        storageFreeIndex = 1;
        printf("%lld\n", getCombineNum(N, NC, baseString));
    // }
}