nyoj 163 Phone List(动态字典树<trie>) poj Phone List (静态字典树<trie>)

Phone List

时间限制：1000 ms  |  内存限制：65535 KB

难度：4

 

描述

Given a list of phone numbers, determine if it is consistent in the sense that no number is the prefix of another. Let's say the phone catalogue listed these numbers:

• Emergency 911
• Alice 97 625 999
• Bob 91 12 54 26

In this case, it's not possible to call Bob, because the central would direct your call to the emergency line as soon as you had dialled the first three digits of Bob's phone number. So this list would not be consistent.

 

输入

The first line of input gives a single integer, 1 ≤ t ≤ 10, the number of test cases. Each test case starts with n, the number of phone numbers, on a separate line, 1 ≤ n ≤ 100000. Then follows n lines with one unique phone number on each line. A phone number is a sequence of at most ten digits.

输出

For each test case, output "YES" if the list is consistent, or "NO" otherwise.

样例输入

2
3
911
97625999
91125426
5
113
12340
123440
12345
98346

样例输出

NO
YES

/**
    题目大意（nyoj 163）：
        判断一个字符串是否是其他字符串的前缀字符串
    
    算法：动态（链表）字典树
    
    步骤：
        Ⅰ、用struct建立字典树的模型（并在其内部构建初始化函数）
        Ⅱ、建立my_insert方法实现将数据的插入（并在插入的时候判断是否满足题意）
        
**/

基础模板代码（node、my_insert）：

struct node
{
    node *next[10];
    int cnt;
    node ()
    {
        cnt = 0;
        memset (next, 0, sizeof (next));
    }
}

node *root = new node();

void my_insert (char *s)
{
    node *p = new node();
    int i, k, len = strlen (s);
    for (i = 0; i < len; ++ i)
    {
        k = s[i] - '0';
        if (p->next [k] == NULL)
            p->next [k] = new node();
        p = p->next [k];
    }
    p->cnt = 1;
    return ;
}

nyoj 163 (AC) CC++代码实现：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>

using namespace std;

int T, n, flag, mark;

char temp[12];

struct node
{
    node *next[10];
    int cnt;
    node ()
    {
        cnt = 0;
        memset(next, 0, sizeof(next));
    }
};

node *root;

void my_insert (char *s)
{
    node *p = root;
    mark = 0;
    int i, k, len = strlen(s);
    for (i = 0; i < len; ++ i)
    {
        k = s[i] - '0';
        if (p->next[k] == NULL)
        {
            mark = 1;
            p->next[k] = new node();
        }
        p = p->next[k];
        if (p->cnt)
        {
            flag = 0;
            return ;
        }
    }
    if (!mark)
    {
        flag = 0;
        return ;
    }
    p->cnt = 1;
    return ;
}

int main()
{
    scanf("%d", &T);
    while(T --)
    {
        flag = 1;
        root = new node();
        scanf("%d", &n);
        while(n --)
        {
            gets(temp);
            if (!flag) continue;
            my_insert (temp);
        }
        if (!flag)
            printf("NO
");
        else
            printf("YES
");
    }
    return 0;
}

下面是poj 3630 的算法：

/**
    题目大意（poj 3630）：
        判断一个字符串是否是其他字符串的前缀字符串
        是 ==>  return NO
        (if all)否 ==> return YES
        
    算法：静态字典树
    
    步骤：
        Ⅰ、用struct建立字典树模型（并在其内部构建初始化函数）
        Ⅱ、建立my_insert方法实现数据的插入（并判断是否满足条件）
**/

基本模型：

int pos;

struct node
{
    node *next[10];
    int cnt;
    node()
    {
        cnt = 0;
        memset(next, 0, sizeof(next));
    }
};

node *root;
pos = 1;

void my_insert (node *root, char *s)
{
    node *p = root;
    int i, k, len = strlen (s);
    for (i = 0; i < len; ++ i)
    {
        k = s[i] - '0';
        if (p->next [k] == 0)
        {
            p->next [k] = root + pos;
            pos ++;
        }
        p = p->next [k];
    }
    p->cnt = 1;
    return ;
}

my_insert(root + 1, temp);

poj 3630 (CC++代码实现 <AC>):

PS:调试用的 node root[10000]。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstring>

using namespace std;

int n, flag, mark, pos;

char temp[12];

struct node
{
    node *next[10];
    int cnt;
    node()
    {
        cnt = 0;
        memset(next, 0, sizeof(next));
    }
};

void my_insert (node *root, char *s)
{
    mark = 0;
    node *p = root;
    int i, k ,len = strlen(s);
    for (i = 0; i < len; ++ i)
    {
        k = s[i] - '0';
        if (p->next[k] == 0)
        {
            mark = 1;
            p->next[k] = root + pos;
            ++ pos;
        }
        p = p->next[k];
        if (p->cnt)
        {
            flag = 1;
            return;
        }
    }
    if (!mark)
    {
        flag = 1;
        return ;
    }

    p->cnt = 1;
    return ;
}

int main () {
    int N;
    scanf ("%d", &N);
    while (N --) {
        flag = 0;
        node root[100005];
        pos = 1;
        scanf("%d", &n);
        while (n --)
        {
            scanf("%s", &temp[0]);
            if (flag) continue;
            my_insert (root + 1, temp);
        }
        if (flag)
            printf("NO
");
        else
            printf("YES
");
    }
    return 0;
}