UVA 156 Ananagrams 关于二维数组表示的字符串排序的问题

题目链接：UVA 156 Ananagrams

Ananagrams

Most crossword puzzle fans are used to anagrams--groups of words with the same letters in different orders--for example OPTS, SPOT, STOP, POTS and POST. Some words however do not have this attribute, no matter how you rearrange their letters, you cannot form another word. Such words are called ananagrams, an example is QUIZ.

Obviously such definitions depend on the domain within which we are working; you might think that ATHENE is an ananagram, whereas any chemist would quickly produce ETHANE. One possible domain would be the entire English language, but this could lead to some problems. One could restrict the domain to, say, Music, in which case SCALE becomes a relative ananagram (LACES is not in the same domain) but NOTE is not since it can produce TONE.

Write a program that will read in the dictionary of a restricted domain and determine the relative ananagrams. Note that single letter words are, ipso facto, relative ananagrams since they cannot be ``rearranged'' at all. The dictionary will contain no more than 1000 words.

Input

Input will consist of a series of lines. No line will be more than 80 characters long, but may contain any number of words. Words consist of up to 20 upper and/or lower case letters, and will not be broken across lines. Spaces may appear freely around words, and at least one space separates multiple words on the same line. Note that words that contain the same letters but of differing case are considered to be anagrams of each other, thus tIeD and EdiT are anagrams. The file will be terminated by a line consisting of a single#.

Output

Output will consist of a series of lines. Each line will consist of a single word that is a relative ananagram in the input dictionary. Words must be output in lexicographic (case-sensitive) order. There will always be at least one relative ananagram.

Sample input

ladder came tape soon leader acme RIDE lone Dreis peat
 ScAlE orb  eye  Rides dealer  NotE derail LaCeS  drIed
noel dire Disk mace Rob dries
#

Sample output

Disk
NotE
derail
drIed
eye
ladder
soon

题意

    一个单词，任意调换字母的次序，即字母重新排列后，能够在字典里面找到相同的形式（不区分大小写），说明它是可以调换的。现在你要找到那些调换之后找不到相同相同形式的那些单词，然后按字典序排列输出来。

分析

    题目不难，但主要的问题是字符串的处理。其实也不用找每个单词的重排列，只要将每个的单词中的字母先都转化为大小写一致的形式然后按升序或降序排列，再一个一个比较是否相等，如果相等，则说明能找到，这两个都标记为true，若都不相等，说明找不到，那么这个就是false，也就是我们要找的单词，注意输出的是单词的原来形式。其实关键的问题在于字符串排序，如果用string来处理的话是很简单的，但是如果用二维字符数组加sort函数的话，就会出现问题，如果单纯的用dic[][]来存储并排序则会报错，但是用*dic[]来存储的话却没有问题，这可能跟sort函数的原型有关。

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

bool cmp1(char a, char b)
{
    return a < b;
}
bool judge(char a[], char b[])
{
    if(strlen(a) != strlen(b)) return false;
    int len = strlen(a);
    char aa[1010], bb[1010];
    strcpy(aa, a);
    strcpy(bb, b);
    for(int i = 0; i < len; i++)
    {
        if(aa[i] >= 'A' && a[i] <= 'Z')
            aa[i] += 'a'-'A';
        if(b[i] >= 'A' && b[i] <= 'Z')
            bb[i] += 'a'-'A';
    }
    sort(aa, aa+len, cmp1);
    sort(bb, bb+len, cmp1);
    if(strcmp(aa, bb) == 0) return true;
    return false;
}
bool cmp2(char* a, char* b)
{
    return strcmp(a, b) < 0;
}
int main()
{
    int n = 0, cnt;
    char str[1010][30];
    char *dic2[30];
    bool vis[1010];
    while(scanf("%s", str[n++]))
        if(str[n-1][0] == '#') break;
    n--;
    memset(vis, false, sizeof(vis));
    cnt = 0;
    for(int i = 0; i < n; i++)
    {
        if(!vis[i])
            for(int j = i+1; j < n; j++)
                if(judge(str[i], str[j]))
                    vis[i] = vis[j] = true;
        if(!vis[i])
            dic2[cnt++] = str[i];
    }
    sort(dic2, dic2+cnt, cmp2);
    for(int i = 0; i < cnt; i++)
        printf("%s\n", dic2[i]);
    return 0;
}