【Acm】算法之美—Anagrams by Stack

题目概述：Anagrams by Stack

　　How can anagrams result from sequences of stack operations? There are two sequences of stack operators which can convert TROT to TORT:

[

i i i i o o o o

i o i i o o i o

]

　　where i stands for Push and o stands for Pop. Your program should, given pairs of words produce sequences of stack operations which convert the first word to the second.

Input

　　The input will consist of several lines of input. The first line of each pair of input lines is to be considered as a source word (which does not include the end-of-line character). The second line (again, not including the end-of-line character) of each pair is a target word. The end of input is marked by end of file.

Output

　　For each input pair, your program should produce a sorted list of valid sequences of i and o which produce the target word from the source word. Each list should be delimited by

[

]

　　and the sequences should be printed in "dictionary order". Within each sequence, each i and o is followed by a single space and each sequence is terminated by a new line.

Process

　　A stack is a data storage and retrieval structure permitting two operations:

Push - to insert an item and

Pop - to retrieve the most recently pushed item

　　We will use the symbol i (in) for push and o (out) for pop operations for an initially empty stack of characters. Given an input word, some sequences of push and pop operations are valid in that every character of the word is both pushed and popped, and furthermore, no attempt is ever made to pop the empty stack. For example, if the word FOO is input, then the sequence:

i i o i o o	is valid, but
i i o	is not (it's too short), neither is
i i o o o i	(there's an illegal pop of an empty stack)

　　Valid sequences yield rearrangements of the letters in an input word. For example, the input word FOO and the sequence i i o i o o produce the anagram OOF. So also would the sequence i i i o o o. You are to write a program to input pairs of words and output all the valid sequences of i and o which will produce the second member of each pair from the first.

Sample Input

madam

adamm

bahama

bahama

long

short

eric

rice

Sample Output

[

i i i i o o o i o o

i i i i o o o o i o

i i o i o i o i o o

i i o i o i o o i o

]

[

i o i i i o o i i o o o

i o i i i o o o i o i o

i o i o i o i i i o o o

i o i o i o i o i o i o

]

[

]

[

i i o i o i o o

]

---

简单描述

 

输入要求

　　输入由多行组成，每对单词占2行。第1行为原始单词（不包括行尾的换行符），第2行为目标单词（同样不包括行尾的换行符）。

输出要求

　　对于输入的每一对字符串，你的程序应该按顺序生成所有的有效的进出栈操作列表，其中的每组操作都能使原字符串转变为目标字符串。每一组操作要由方括号括起来，其中i表示压入，o表示弹出。

程序要求

　　可能有多组有效操作都能够为输入的单词生成指定的字母排列。比如对于输入的单词“FOO”，操作i i o i o o就可以生成重排的单词“OOF”。操作i i i o o o也可以生成同样的重排。你要写一个程序，找出所有有效的操作序列，以使输入的一对单词的前者重排为后者。

---

题目分析

　　这道题必须遍历所有可能的进出栈序列才能求得全部解。因此同Crashing Balloon解法一样，属于DFS（深度优先搜索）加回溯。

---

解题算法

　　注释相当完整，如题

#include<stdio.h>
#include<string.h>
#define MAX_LEN 100
#define STACK_SIZE 200

char source[MAX_LEN],       /* 源字符串 */
    target[MAX_LEN],        /* 目标字符串 */
    stack[STACK_SIZE];      /*  栈*/
int state[2*MAX_LEN];       /* 每一阶段的状态，也就是路径OR解，状态1表示压栈；-1表示弹栈 */
int len;                    /* 字符串长度 */
int flag=0;                 /* 标记是否有解 */

int print(int depth)        /* 输出结果 */
{
    int i=0;
    while(i<depth-1)        /* 这里是i<depth-1不是i<depth否则会多出空格 */
    {
        if(state[i]==1)     /* 用1表示压栈；-1表示弹栈 */
            putchar('i');
        if(state[i]==-1)
            putchar('o');
        if(i<depth-1)       /* ATTENTION!不是每一个后面都有空格，最后一个字符后没有！ */
            putchar(' ');
        i++;
    }
    putchar('\n');
    return 0;
}

int dfs(int depth,int npush,int npop)       /* depth：深搜的深度；npush：压栈数；npop：弹栈数 */
{
    if(npush==len&&npop==len)               /* 求解完成 */
    {
        flag=1;                             /* 修改标志：有解 */
        print(depth);                       /* 输出解 */
        return 0;
    }
    if(npush<len)                           /* 可以压栈 */
    {
        state[depth-1]=1;                   /* 记录状态，1表示入栈 */
        stack[stack[0]]=source[npush];      /* 入栈，将源npush位置的字符压入栈顶 */
        stack[0]++;                         /* 改变栈顶指针，栈后移 */
        dfs(depth+1,npush+1,npop);          /* GO ON，进行压栈判断 */
        stack[0]--;     /* 回溯要恢复栈的状态，因为不是每一次调用都复制一次栈。那样开销大 */
    }
    if(stack[0]>0&&target[npop]==stack[stack[0]-1]) /* 判断是否可以弹栈，不能弹栈就回溯 */
    {
        state[depth-1]=-1;              /* 记录状态, -1表示弹栈 */
        int tmp=stack[stack[0]-1];      /* 因为要弹栈，所以要保存栈原来的状态，tmp记录的是栈顶的位置 */
        stack[0]--;                     /* 改变栈顶指针 */

        dfs(depth+1,npush,npop+1);      /* 继续DFS，进行弹栈判断 */
        stack[stack[0]]=tmp;            /* 不能弹栈就回溯，恢复栈的状态 */
        stack[0]++;                     /* 恢复栈顶指针 */
    }
    return 0;
}

int main(void)
{
    stack[0]=1;                         /* stack[0]指向栈顶的上一位；初始化*/
    while(scanf("%s%s",source,target)!=EOF)
    {
        puts("[");
        flag=0;                         /* 初始化标志 */
        len=strlen(source);
        if(len==strlen(target))         /* 长度不同=》跳过 */
            dfs(1,0,0);
        puts("]");
    }
    return 0;
}