HDU 1247

Hat’s Words

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 8556    Accepted Submission(s): 3082

Problem Description

A hat’s word is a word in the dictionary that is the concatenation of exactly two other words in the dictionary.
You are to find all the hat’s words in a dictionary.

 

Input

Standard input consists of a number of lowercase words, one per line, in alphabetical order. There will be no more than 50,000 words.
Only one case.

 

Output

Your output should contain all the hat’s words, one per line, in alphabetical order.

 

Sample Input

  
  

   
   a
ahat
hat
hatword
hziee
word
  
  

 

Sample Output

  
  

   
   ahat
hatword
  
  

//题意说的是给一些单词，找出是其中的一些单词所组成的单词

//解题思路：用字典树记录下所有的单词，然后对所有的单词拆分成两部分，然后把得到的两部分在字典树中查找
//如果在字典树中两部分都找到就说明符合题意中所的要求，是hat’s words，直接输出
#include<iostream>
#include<stdio.h>
#include<string.h>

#include<stdlib.h>

using namespace std;

char str[50005][50], temp1[50], temp2[50];

typedef struct node
{
    bool flag;//标记单词末尾，并且可以作为下面find()函数的返回值
    struct node *next[26];
} Node;

Node *root;//全局变量

Node *newNode()//开辟新节点并初始化
{
    Node *p;
    p = (Node *)malloc(sizeof(Node));
    for (int i = 0; i < 26; i++)
    {
        p->next[i] = NULL;
    }
    p->flag = 0;//必须初始化0,一开始初始化为1，wrong了好多次
    return p;
}

void insert(char *s)
{
    Node *p;
    p = root;
    for (int i = 0; i < strlen(s); i++)
    {
        if (p->next[s[i]-'a'] == NULL)
        {
            p->next[s[i]-'a'] = newNode();
        }
        p = p->next[s[i]-'a'];
    }
    p->flag = 1;
}

int find(char *s)
{
    Node *p;
    p = root;
    for (int i = 0; i < strlen(s); i++)
    {
        if (p->next[s[i]-'a'] != NULL)
        {
            p = p->next[s[i]-'a'];
        }
        else
            return 0;
    }
    return p->flag;
}

int main()
{
    int i = 0;
    root = newNode();
    while (gets(str[i]))
    {
        insert(str[i++]);
    }
    for (int j = 0; j < i; j++)
    {
        int len = strlen(str[j]);
        for (int k = 0; k < len; k++)
        {
            temp1[k] = str[j][k];
            temp1[k+1] = '\0';
            if (k < len-1)
            {
                strcpy(temp2, str[j]+k+1);
                if (find(temp1) && find(temp2))
                {
                    puts(str[j]);
                    break;//避免多次输出相同的hatword
                }
            }
        }
    }
    return 0;
}