ACM/ICPC 之 递归(POJ2663-完全覆盖+POJ1057(百练2775)-旧式文件结构图)

POJ2663-完全覆盖

题解见首注释

//简单递推-三个米诺牌(3*2)为一个单位打草稿得出规律
//题意-3*n块方格能被1*2的米诺牌以多少种情况完全覆盖
//Memory 132K Time: 0 Ms

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

int ans;

//开始平铺
int Tiling(int n)
{
    int sum = ;
    if (n == )
        return ;
    else if (n >= )
    {
        sum +=  * Tiling(n - );
        while (n -= , n -  >= )
            sum += *Tiling(n-);
    }
    return sum;
}

int main()
{
    int n;
    while (scanf("%d",&n),n != -)
    {
        ans = Tiling(n);
        printf("%d\n", ans);
    }
    return ;
}

---

POJ1057(百练2775)-旧式文件结构图

非递归版-注意记录状态

//旧式shell文件结构图模拟-分析文件(可递归)
//Memory: 148K  Time: 0 Ms

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

#define MAX 62

char buff[MAX][MAX];

/* File name */
struct File{
    char f[MAX];
};

/* Folder property */
struct Folder{
    int catalog;
    int num;
    File f[MAX];
}dir[MAX];

/* sort_cmp */
bool cmp(File a,File b)
{
    return strcmp(a.f, b.f) < ;
}

void open_Folder(int cur,int num)    //cur-当前文件目录，num-文件数
{
    int i, j;
    sort(dir[cur].f, dir[cur].f + num, cmp);
    for (i = ; i < num; i++)
    {
        for (j = ; j < dir[cur].catalog; j++)
            printf("|     ");
        printf("%s\n", dir[cur].f[i].f);
    }
}

int main()
{
    int T, n;
    int i, j, k;
    T = ;
    while (scanf("%s", buff[]), buff[][] != '#')
    {
        /*Reading all*/
        n = ;
        k = ;
        while (scanf("%s", buff[++n]), buff[n][] != '*');
        printf("DATA SET %d:\n",++T);
        printf("ROOT\n");
        dir[].num = ;    //Init

        for (i = ; i <= n; i++)
        {
            if (buff[i][] == 'd')    //Folder
            {
                k++;
                dir[k].catalog = dir[k-].catalog+;
                dir[k].num = ;
                for (j = ; j < dir[k].catalog; j++)
                    printf("|     ");
                printf("%s\n", buff[i]);
            }
            else if (buff[i][] == 'f')    //File
                strcpy(dir[k].f[dir[k].num++].f, buff[i]);
            else if (buff[i][] == ']')    //end_Folder
            {
                open_Folder(k, dir[k].num);
                k--;
            }
            else if (buff[i][] == '*')    //end_root
                open_Folder(k, dir[k].num);
        }
        printf("\n");
    }
    return ;
}

递归版-用形参记录状态

-PS：这个版本是本文发表当天写的，所以和上面版本(前一年做过的)的习惯和极值有些差异。

//递归模拟
//Memory:184K Time:0Ms
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

#define MAX 31

int T;    //当前为第T个样例
char cur[MAX];    //当前输入字符串

//FILE *out = fopen("out.txt", "w");

struct File {
    char name[MAX];
    friend bool operator < (File a, File b)
    {
        if (strcmp(a.name, b.name) < ) return true;
        else return false;
    }
};

struct Catalog {
    char name[MAX];
    int num;    //该目录下的文件数
    File f[MAX];
    Catalog(char *name) { strcpy(this->name, name); num = ; }
};

void open(char *name,int level)
{
    if (name[] == 'R')    //ROOT前输入
        printf("DATA SET %d:\n", ++T);
        //fprintf(out, "\nDATA SET %d:\n", ++T);
    while (level--)
        printf("|     ");
        //fprintf(out,"|     ");
    printf("%s\n", name);
    //fprintf(out, "%s\n", name);
}

void root(Catalog dir,int level)
{
    scanf("%s", cur);

    if (cur[] == '#') return;    //END

    open(dir.name, level);

    do{
        if (cur[] == 'd')
        {
            Catalog newDir(cur);    //创建新文件夹，命名为cur
            root(newDir, level + );
        }
        else if(cur[] == 'f')
            strcpy(dir.f[dir.num++].name, cur);
        else {    //cur[0] == ']' or cur[0] == '*'
            sort(dir.f, dir.f + dir.num);
            for (int i = ; i < dir.num; i++)
                open(dir.f[i].name, level);
            return;
        }
    }while (scanf("%s", cur));
}

int main()
{
    while (cur[] != '#')
    {
        Catalog r("ROOT");    //创建根目录
        root(r,);
        printf("\n");
    }

    return ;
}