深圳商业网站建设哪家专业/新浪体育nba

题意：

 只有一组数据，数据量为20M

根据单词出现顺序输出出现次数..

 

思路：

3种方法：① map  ② BKDR求hash值<hash表的线性再散列方法或者是链表形式>

map的方法因为数据量很大..容易超时

 

 

Tips：

※ BKDR求字符串hash值方法：

 

unsigned int BKDRHash(char *str)
{
    unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
    unsigned int hash = 0;

    while (*str)
    {
        hash = hash * seed + (*str++);
    }

    return (hash & 0x7FFFFFFF);
}

 

 

 

原创是byvoid大人~

 

※学到了一种存所有单词的最省空间方法..

char buf[MAX_SIZE];
char *sa[MAXN];
char *ch;
int cnt;
// 读入字符串
ch = buf;
while (EOF != scanf("%s", ch)) {
    sa[cnt++] = ch;
    ch += strlen(ch) + 1;
}

原创是黄老~

 

※ 以前用map的时候都是

if(map[str] == 0) map[str] = tot++;

count[map[str]]++;

这样..但是因为调用map其实很费时间..

所以改进为int tmp = map[str];

if(tmp != 0) count[tmp]++;

else {

　　map[str] = tot++;

　　count[tot-1] = 1;

}

 

※ 对于hash链表和BKDR求hash值方法~个人感觉可以不一起使用~

hash链表比线性再散列快..因为不管是插入新值还是查询的时候都比线性再散列比较次数少..但是BKDR已经可以很大程度的减少了冲突..所以重叠使用反而不如BKDR+线性再散列快..

 

※ ※ ※ 这里无法忽视的都是数据的存储问题..

数组的大小很难控制..

太大了程序要崩溃..太小了会越界~

所以代码是存在问题的..

在数组大小那里..仅仅因为数据弱而ac了..

 

解决方案可以是先把字符串读入并记录单词个数

然后根据单词个数为数组开内存..

而解决单词的问题就用黄老的单词缓存方法~

 

Code：

#include <stdio.h>
#include <map>
#include <string>
using namespace std;

map<string, int> m;
char arr[4000024];
int cnt[100024];
int main()
{
    int tot = 1;
    while(scanf("%s", arr) != EOF) {
        int tt = m[arr];
        if(tt != 0) cnt[tt]++;
        else {
            m[arr] = tot++;
            cnt[tot-1]++;
        }
    }
    for(int i = 1; i < tot; ++i)
        printf("%d\n", cnt[i]);
    return 0;
}

 

#include <stdio.h>
#include <cstring>
using namespace std;
const int MAX_SIZE = 21000000;
const int MAXN = 3000;

struct Node
{
    char *s;
    Node *next;
    int value;
}*hash[MAX_SIZE], *p;

unsigned int BKDRHash(char *str) {
    unsigned int seed = 131; //31 131 1313 13131 131313 etc...
    unsigned int hash = 0;

    while(*str) hash = hash*seed + (*str++);

    return (hash&0x7FFFFFFF);
}

char buf[MAX_SIZE];
int cnt[180000];
int tot;
char *ch;
unsigned int key;

int main()
{
    bool flag;
    ch = buf;
    tot = 0;
    for(int i = 0; i < MAXN; ++i)
    hash[i] = NULL;
    while(EOF != scanf("%s", ch)) {
        flag = false;
        key = BKDRHash(ch);
        for(p = hash[key%MAXN]; p; p = p->next)
        if(strcmp(p->s, ch) == 0) {
            cnt[p->value]++;
            flag = true;
        }
        if(!flag) {
            Node *tmp = new Node;
            tmp->s = ch;
            tmp->value = tot++;
            cnt[tot-1] = 1;
            tmp->next = hash[key%MAXN];
            hash[key%MAXN] = tmp;
            ch = ch+strlen(ch)+1;
        }
    }
    for(int i = 0; i < tot; ++i)
    printf("%d\n", cnt[i]);
    return 0;
}

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

const int maxn = 180000;

int BKDRHash(char *str)
{
    int hash = 0;
    while (*str)
    {
        hash = hash*31 + (*str++);
    }
    return (hash & 0x7FFFFFFF);
}

struct node
{
    int count;
    char *s;
}h[maxn];

int num[maxn]={0};
int tot = 0;
void hashinsert(char *str)
{
    int val = BKDRHash(str)%maxn;
    while (h[val].count != 0)
    {
        if (strcmp(h[val].s,str)==0)
        {
            h[val].count++;
            break;
        }
        val = (val+1)%maxn;
    }
    if (h[val].count == 0)
    {
        int len = strlen(str);
        h[val].s = (char*)malloc(sizeof(char)*(len+1));
        strcpy(h[val].s,str);
        h[val].count++;
        num[++tot] = val;
    }
}

char ss[3000000];

int main()
{
    memset(h,0,sizeof(h));
    while (scanf("%s",ss)!=EOF)
    {
        hashinsert(ss);
    }
    int i;
    for (i=1; i<=tot; i++)
        printf("%d\n",h[num[i]].count);
    return 0;
}

 

题目链接：

http://acm.hrbust.edu.cn/index.php?m=ProblemSet&a=showProblem&problem_id=1618