homework-04

一. 程序设计想法：

于是这次我实在是懵了...真的不会啊...(好在后来得知是个np问题)...

于是听从老师的建议，先从判定算法写起...

于是第一反应这是一个八方搜索啊

我从1~n,1~n表示一个二维字符矩阵，不从0开始的好处是防止溢出。

dfs(int x,int y,int direct,int num,int k)

分别表示此时搜到的坐标为(x,y)，方向为direct(若为0则启动1~8循环方向)，num为此时序列符合第几个单词(若为-1则启动1~count循环判定符合与否)，k表示此时为第num个单词的第k个字母(当k==第num个单词长度时，则搜到完整单词)。

似乎就是一个全排列类似的写法。

需要记录的就是给定的count个单词是否被覆盖且仅被覆盖一次，二维字符矩阵中的每个字符被覆盖了多少次，是否4个顶点都被覆盖，是否有一行或一列没有被覆盖，是否8个方向都满足数量。

似乎简单但写起来却挺费劲。前几天刚写了个数独的解法，用的就是类似的搜索...事实证明可行...

但是

同组小伙伴王文涛提出：我为什么不能暴力一下? 就是对每一个字符进行和给定字符串第一个字符匹配，如果相同则八方暴力搜索。

真暴力！但似乎和搜索的时间复杂度差不多0.0

于是就给他搞了...

我来写生成算法T.T怎么能这样！

还是老办法，分步写...

第一个模块：字符串预处理，把中间空格去掉

int StringPretreatment(int Temp)
{
    int Length = strlen(StringInput[Temp]);
    for (int i = 0;i < Length;i++)
    {
        if (StringInput[Temp][i] == ' ')
        {
            for (int j = i + 1;j < Length;j++)
                StringInput[Temp][j - 1] = StringInput[Temp][j];
            StringInput[Temp][Length - 1] = EOF;
            Length--;i--;
        }
    }
    return Length;
}

第二个模块：字符串按长度排序(由于数量不多我就用冒泡了)

void StringSort()
{
    int i,j,k;
    char StringTemp[25];
    for (i = 0;i < StringCount - 1;i++)
        for (j = i + 1;j < StringCount;j++)
            if (StringLength[i] < StringLength[j])
            {
                k = StringLength[i];
                StringLength[i] = StringLength[j];
                StringLength[j] = k;
                strcpy(StringTemp,StringInput[i]);
                strcpy(StringInput[i],StringInput[j]);
                strcpy(StringInput[j],StringTemp);
            }
}

 我的想法是用2个横&2个竖填充四条边，保证每个单词占据一个顶点，构成一个“卍”(没有中间的十字)

于是代码如下：

void FirstStep()
{
    int i,j;
    for (i = 0;i < maxN;i++)
        for (j = 0;j < maxN;j++) OutputMatrix[i][j] = ' ';
    for (i = 0;i < StringLength[0];i++)
        OutputMatrix[0][i] = StringInput[0][i];
    for (i = 0;i < StringLength[1];i++)
        OutputMatrix[maxN - 1][maxN - StringLength[1] + i] = StringInput[1][i];
    for (i = 0;i < StringLength[2];i++)
        OutputMatrix[maxN - StringLength[2] + i][0] = StringInput[2][i];
    for (i = 0;i < StringLength[3];i++)
        OutputMatrix[i][maxN - 1] = StringInput[3][i];
}

接着继续生成字符矩阵，由于横向正&竖向正已经满足条件，于是我偷懒的不写这两种情况了，剩下的字符串都以剩下6种填充。

我的办法是暴力填充，所选位置为此字符串满足填充条件的第一个位置，因此也就没法保证最小性，但是要是使用dfs枚举所有位置，时间肯定会爆掉。

选取每个字符串走向的办法是对字符串序号取模，对应剩下6种走向。

int StringJudge(int direct,int num,int x,int y)
{
    int i,flag = 0,res = 0;
    if (direct == 0)
    {
        if (y >= StringLength[num])
        {
            for (i = 0;i < StringLength[num];i++)
                if (OutputMatrix[x][y - i] != ' '
                && OutputMatrix[x][y - i] != StringInput[num][i]) flag = 1;
            if (flag == 0) res = 1;
        }
    }
    if (direct == 1)
    {
        if (x >= StringLength[num])
        {
            for (i = 0;i < StringLength[num];i++)
                if (OutputMatrix[x - i][y] != ' '
                && OutputMatrix[x - i][y] != StringInput[num][i]) flag = 1;
            if (flag == 0) res = 1;
        }
    }
    if (direct == 2)
    {
        if ((StringLength[num] + x) <= maxN && (StringLength[num] + y) <= maxN)
        {
            for (i = 0;i < StringLength[num];i++)
                if (OutputMatrix[x + i][y + i] != ' '
                && OutputMatrix[x + i][y + i] != StringInput[num][i]) flag = 1;
            if (flag == 0) res = 1;
        }
    }
    if (direct == 3)
    {
        if (x >= StringLength[num] && y >= StringLength[num])
        {
            for (i = 0;i < StringLength[num];i++)
                if (OutputMatrix[x - i][y - i] != ' '
                && OutputMatrix[x - i][y - i] != StringInput[num][i]) flag = 1;
            if (flag == 0) res = 1;
        }
    }
    if (direct == 4)
    {
        if (y >= StringLength[num] && (x + StringLength[num]) <= maxN)
        {
            for (i = 0;i < StringLength[num];i++)
                if (OutputMatrix[x + i][y - i] != ' '
                && OutputMatrix[x + i][y - i] != StringInput[num][i]) flag = 1;
            if (flag == 0) res = 1;
        }
    }
    if (direct == 5)
    {
        if (x >= StringLength[num] && (y + StringLength[num]) <= maxN)
        {
            for (i = 0;i < StringLength[num];i++)
                if (OutputMatrix[x - i][y + i] != ' '
                && OutputMatrix[x - i][y + i] != StringInput[num][i]) flag = 1;
            if (flag == 0) res = 1;
        }
    }
    return res;
}
void StringIntoMatrix(int direct,int num,int x,int y)
{
    int i;
    if (direct == 0)
    {
        for (i = 0;i < StringLength[num];i++) OutputMatrix[x][y - i] = StringInput[num][i];
    }
    if (direct == 1)
    {
        for (i = 0;i < StringLength[num];i++) OutputMatrix[x - i][y] = StringInput[num][i];
    }
    if (direct == 2)
    {
        for (i = 0;i < StringLength[num];i++) OutputMatrix[x + i][y + i] = StringInput[num][i];
    }
    if (direct == 3)
    {
        for (i = 0;i < StringLength[num];i++) OutputMatrix[x - i][y - i] = StringInput[num][i];
    }
    if (direct == 4)
    {
        for (i = 0;i < StringLength[num];i++) OutputMatrix[x + i][y - i] = StringInput[num][i];
    }
    if (direct == 5)
    {
        for (i = 0;i < StringLength[num];i++) OutputMatrix[x - i][y + i] = StringInput[num][i];
    }
}
void MatrixProduce(int StringNum)
{
    int StringDirect = StringNum % 6;
    int i,j,flag = 0,suit;
    for (i = 0;i < maxN;i++)
    {
        for (j = 0;j < maxN;j++)
        {
            if (OutputMatrix[i][j] == ' ' || OutputMatrix[i][j] == StringInput[StringNum][0])
            {
                suit = StringJudge(StringDirect,StringNum,i,j);
                if (suit == 1)
                {
                    StringIntoMatrix(StringDirect,StringNum,i,j);
                    flag = 1;
                }
            }
            if (flag == 1) break;
        }
        if (flag == 1) break;
    }
}

这样似乎就可以了...当然只要maxN足够大的话，肯定能够把所有字符串放进去，满足全部条件除没有一行一列都是无用字符。

对于那组比较少的数据：

于是空格就是随意填的字符...

需要注意的是，我设定的第一步要求最小的maxN要比最长单词长度大1。

对于那组比较多的数据：

我们能做到20*20的矩阵，这是我们程序能找到的最小解。

最下面两个数字代表总共多少个单词以及成功打印了多少个单词。

二. 时间安排：

预计时间	5h	实际用时	6h
代码规范	0.5h		0.5h
具体设计	0.5h		1h
具体编码	2.5h		3h
代码复审	0.5h		0h
代码测试	0.5h		1h
测试报告	0.5h		0.5h

 三. 官方样例测试：(测试程序为王文涛所写)

test1

test2

test3

test4我们试了很多种生成算法(改变不同走向)，结果还是通不过检测。

后来............

MUM是无论如何也通不过测试的啊！！！

忽略...

test5

就是这样了...算是较优解吧...

检测代码请见王文涛blogs。