UVa 502 DEL command

题目链接：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=24&page=show_problem&problem=443

这题刚开始看的时候小郁闷了一下，入门经典把它放在难回溯的分类里，可我怎么也没觉得它跟回溯有啥关系，于是搁置了很久。

题意：-是需要删除的文件，+是需要保留的文件，构造一个字符串，使它能一步删除所有需要删除的文件，同时不会误删需要保留的文件。

思路：遍历所有需要删除的文件，相同位置字母相同的话，就填充那个字母，否则填充'?'，最后长度不匹配补'*'。构造完成后，验证是否会删掉需要保留的文件。

测试数据参考：http://hi.baidu.com/zyz913614263/item/7bd90a4474cd82f7bcf45166

不过因为百度空间把空格跟弄没了，我也不知道学长那组数据是怎么分的，于是我根据自己的理解又重新分了一下：

INPUT

9

-A
-AA
-AAA
+AAAA

-AAA
-AAAA
+AA

-AB
-AA
+AAAA

-AB
-BB
+ABAA

-X.A
-X.AA
+X.AAA

-X.AB
-X.AA
+X.AAA

-X.AB
-X.BB
+X.ABA

-X.A
-X.AA
+X
-X.AA
-X.AAA
+X.A

-X.AB
-X.BB
+X.ABA
-X.A

OUTPUT:

IMPOSSIBLE

DEL AAA*.

DEL A?.

DEL ?B.

IMPOSSIBLE

DEL X.A?

DEL X.?B

IMPOSSIBLE

IMPOSSIBLE

#include <cstdio>
#include <cstring>
#include <cstdlib>

const int MAXN = 1010;

struct node
{
    char ch;     //保留还是删除
    char name[10];    //文件名
    char tuozhan[5];   //拓展名
    int len1, len2;   //len1 - 文件名串长度 len2 - 拓展名串长度
};

node D[MAXN];
char ans[100];   //答案文件名
char ansT[10];   //答案拓展名
int anslen, ansTlen;   //答案文件名长度，答案拓展名长度
int N;        //全部文件个数
int jian;     //需要删除的文件个数
int minLen;    //需要删除的文件中文件名的最小长度
int tuozhanMinLen;   //需要删除的文件中拓展名的最小长度
bool lenflag;     //需要删除的文件中，文件名是否有跟最小长度不等长的
bool tuozhanlenflag;   //需要删除的文件中，拓展名是否有跟最小长度不等长的

int cmp( const void *a, const void *b )   //排序，需要删除的文件排在前，保留的排在后
{
    node *c = ( node *)a;
    node *d = ( node *)b;
    return d->ch - c->ch;
}

bool check()    //检查是否会删掉需要保留的文件
{
    bool flag = true;
    for ( int i = jian; flag && i < N; ++i )
    {
        flag = false;   //可以删
        for ( int j = 0; j < minLen && j < D[i].len1; ++j )
        {
            if ( ans[j] == '?' ) continue;
            if ( D[i].name[j] != ans[j] )   // 若有字符不同
            {
                flag = true;   //不可删
                break;
            }
        }

        if ( !flag )   //检验长度是否符合
        {
            if ( ans[anslen - 1] == '*' )
            {
                if ( anslen - 1 > D[i].len1 ) flag = true;
            }
            else if ( anslen != D[i].len1 ) flag = true;
        }

        if ( !flag )  //如果文件名可删，再检查拓展名
        {
            for ( int j = 0; j < tuozhanMinLen && j < D[i].len2; ++j )
            {
                if ( ansT[j] == '?' ) continue;
                if ( D[i].tuozhan[j] != ansT[j] )   //存在不同字符
                {
                    flag = true;    //不可删
                    break;
                }
            }

            if ( !flag )   //检验长度是否符合
            {
                if ( ansT[ ansTlen - 1 ] == '*' )
                {
                    //printf( "%d %d\n", D[i].len2, ansTlen - 1 );
                    if ( D[i].len2 < ansTlen - 1  ) flag = true;
                }
                else if ( ansTlen != D[i].len2 ) flag = true;
            }
        }
    }
    if ( flag ) return true;
    else return false;
}

void solved( )  //构造答案
{
    for ( int i = 0; i < minLen; ++i )
    {
        bool flag = true;
        for ( int j = 1; j < jian; ++j )
        {
            if ( D[j].name[i] != D[j - 1].name[i] )
            {
                flag = false;
                break;
            }
        }
        if ( flag ) ans[i] = D[0].name[i];
        else ans[i] = '?';
    }
    int len = minLen;
    if ( lenflag ) ans[len++] = '*';
    ans[len++] = '.';
    ans[len] = '\0';
    //puts(ans);
    anslen = len - 1;


    for ( int i = 0; i < tuozhanMinLen; ++i )
    {
        bool flag = true;
        for ( int j = 1; j < jian; ++j )
        {
            if ( D[j].tuozhan[i] != D[j - 1].tuozhan[i] )
            {
                flag = false;
                break;
            }
        }
        if ( flag ) ansT[i] = D[0].tuozhan[i];
        else ansT[i] = '?';
    }
    len = tuozhanMinLen;
    if ( tuozhanlenflag ) ansT[ len++ ] = '*';
    ansT[ len ] = '\0';
    //puts(ansT);
    ansTlen = len;

    if ( check() ) printf( "DEL %s%s\n", ans, ansT );
    else puts("IMPOSSIBLE");

    return;
}

int main()
{
    int T;
    char temp[50];
    scanf( "%d", &T );
    getchar();
    getchar();
    while ( T-- )
    {
        memset( D, '\0', sizeof(D) );
        N = 0;
        minLen = 1000;
        tuozhanMinLen = 100;
        lenflag = false;
        tuozhanlenflag = false;
        while ( gets( temp ) != NULL && temp[0] != '\0' )
        {
            D[N].ch = temp[0];

            int i = 1, j = 0;
            int len = strlen(temp);

            while ( i < len && temp[i] != '.' )   //提取文件名
                D[N].name[j++] = temp[i++];
            D[N].name[j] = '\0';
            D[N].len1 = j;
            if ( D[N].ch == '-' )
            {
                if ( j < minLen ) minLen = j;
                //if ( j != minLen ) lenflag = true;
            }

            j = 0;++i;
            while ( i < len )    //提取拓展名
                D[N].tuozhan[j++] = temp[i++];
            D[N].tuozhan[j] = '\0';
            D[N].len2 = j;
            if ( D[N].ch == '-' )
            {
                if ( j < tuozhanMinLen ) tuozhanMinLen = j;
                //if ( j != tuozhanMinLen ) tuozhanlenflag = true;
            }
            ++N;
        }

        qsort( D, N, sizeof(D[0]), cmp );

        jian = 0;
        for ( int i = 0; i < N; ++i )
        {
            //printf( "%s %s\n", D[i].name, D[i].tuozhan );
            if ( D[i].ch == '+' ) break;
            if ( D[i].len1 != minLen ) lenflag = true;
            if ( D[i].len2 != tuozhanMinLen ) tuozhanlenflag = true;
            ++jian;
        }
        //printf( "%d %d\n", N, jian );
        memset( ans, '\0', sizeof(ans) );
        solved();
        if (T) puts("");   //两组数据之间输出一个空行
    }
    return 0;
}