3

所以,这是学校的每周项目,我已经让它完全正常工作,但感觉好像我做的方式,可能不是最好的方法之一(甚至不是好方法)。我希望你们可以帮助优化它/提供更好的解决方案。我已经提交了这个版本,但想知道一个更优化的解决方案。


所以开始,这里的问题...

万圣节快到了,Linus 出发去花园等待大南瓜。不幸的是,由于多样化,今年花园里还有很多其他的葫芦,所以他需要你写一个程序告诉他有多少块南瓜,它们有多大。

该程序的输入将是许多不同的花园。每个花园的输入的第一行将是花园的尺寸,r,花园中的行数,c,列数,其中 0 ≤ r ≤ 40 和 0 ≤ c ≤ 40。尺寸将是 r 行,每行有 c 个字符。这些字符中的每一个都将是一个小写字母,代表正方形中种植的葫芦类型。小写的“p”代表南瓜。行数和/或列数为 0 的花园表示输入结束,不应处理。

示例输入:

10 10
pzzzzzzzzp
pyypzzzzzy
ppppssssyy
ssspssssyy
ssssppssyy
ssssppsspy
zzzzzzsspy
zzzzzzsspy
yyyypzsspy
yyyypppppy
3 4
pppp
pppp
pppp
1 7
zzzzzzz
0 0

对于每个花园,按从小到大的顺序输出花园的数量(第一个输入集为花园 1)、花园中南瓜块的数量以及南瓜块的大小。如果给定大小的补丁不止一个,则打印该大小的次数。使用以下格式:

示例输出:

Garden # 1: 4 patches, sizes: 1 4 8 10 
Garden # 2: 1 patches, sizes: 12
Garden # 3: 0 patches, sizes: 

注意:即使问题说从文件输入,我们的教授告诉我们通过键盘输入。


我的方法是将花园放入一个 2d 数组中,周围有 x 的边界。然后我会使用一个函数来找到一个南瓜补丁(并返回它的坐标)。然后,我将使用另一个函数递归地查找南瓜是否通过上、下、左和右连接到该南瓜,并返回南瓜补丁的大小。此函数还通过将每个南瓜替换为“x”来“删除”每个南瓜。这让我不必担心多次寻找南瓜。

所以这是我的代码,注释很好,希望你们能理解我想要做什么。

#include <iostream>
#include <fstream> 

using namespace std; 

const int MAX_ROW = 41; 
const int MAX_COL = 41; 

char input (); 

int checkForPatchSize ( char arr[][MAX_COL], int numOne, int numTwo ); 

bool findPatch ( char arr[][MAX_COL], int &row, int&col ); 

void sort ( int arr[], int size);

int main () 
    {
    int inputNumOne = -1;  // Defaulted to -1, First number for Patch Size
    int inputNumTwo = -1;  // Defaulted to -1, Second number for Patch Size
    int i, j;      // i, j are indexes for loops, number
    int numArr[MAX_ROW][MAX_COL]; // Array for storing Data
    int indexGarden = 0;  
    int index = 1; 

    while ( inputNumOne != 0 ) 
        {
        cin >> inputNumOne;       // User inputs Dimension
        cin >> inputNumTwo;       // Of Garden...
        if ( inputNumOne != 0 and inputNumTwo != 0 )   // End case is that both are 0. 
            { 
            char pumpkinPatch[MAX_ROW][MAX_COL];   // Array for storing pumpkin patch info. 
            for ( i = 0; i < inputNumOne+2; i++ )   
                {
                for ( j = 0; j < inputNumTwo+2; j++ ) 
                     {
                    // This if statement surrounds the garden in X's so that I have a border (allows me to not have to worry about test cases. 
                    if ( i == 0 or j == 0 or i == inputNumOne + 1 or j == inputNumTwo + 1 ) 
                        {
                        pumpkinPatch[i][j] = 'x'; 
                        }
                    else   // This is the input of the garden into a 2d array.
                        {
                        pumpkinPatch[i][j] = input(); 
                        }
                    }

                }




            int row, col, size, numberOfPatches = 0; 
            bool foundPatch = true; 
            index = 1; 

            while ( foundPatch == true )
                {
                row = inputNumOne+2;  // Because I added a border to the garden
                col = inputNumTwo+2;  // the size is +2 of what the user input. 
                foundPatch = findPatch ( pumpkinPatch, row, col );  // Finds the start of a pumpkin patch, and returns the coordinates ( as row and col ). 
                if ( foundPatch == true ) // If a patch is found....
                    {
                    numberOfPatches++;  // Increase number of patches 
                    size = checkForPatchSize ( pumpkinPatch, row, col); // find size of particular patch
                    numArr[indexGarden][index] = size; // put size into data arr (to be printed to screen later). 
                    index++;  


                    }

                }
                numArr[indexGarden][0] = numberOfPatches; // Put number of patches as first item in each column of data arr. 
                indexGarden++; 


            }

        }

    for ( index = 0; index < indexGarden; index++ ) // Print out Garden Info
        {
        cout << "Garden # " << index + 1 <<": " << numArr[index][0] << " patches, sizes: "; 
        int temp = numArr[index][0]; // temp is the number of patches in particular garden. 
        int tempArr[temp];   // temp array to be used for sorting
        int indexTwo; 
        for ( indexTwo = 0; indexTwo < temp; indexTwo++ ) 
            {
            tempArr[indexTwo] = numArr[index][indexTwo+1];   // Transfer sizes into a temp array so that they can be sorted.    

            }
        sort (tempArr, temp);  // Sort ( Sorts arr from smalles to larges ) 

        for ( indexTwo = 0; indexTwo < temp; indexTwo++ )  // Output sorted array to screen.  
            {
            cout << tempArr[indexTwo] << " "; 
            }

        cout << endl; 
       }
     

     



    }

char input()
   {
    char letter; 
    cin >> letter; 
    return letter; 
    } 
/////////////// findPatch /////////////////////////////////////////////////
// Requirements: a 2D array of garden, and the size of it (row and col). //
// Returns a bool, true if patch is found, false if no patches found.    //
// row and col are returned by reference to be the coordinates of one    //
//  of the pumpkins in the patch.                                    //
/////////////////////////////////////////////////////////////////////////// 
bool findPatch ( char arr[][MAX_COL], int &row, int&col ) 
    {
    int rowIndex = 0; 
int colIndex = 0; 

while ( arr[rowIndex][colIndex] != 'p' and rowIndex < row ) 
    {
    colIndex = 0; 
    while ( arr[rowIndex][colIndex] != 'p' and colIndex < col ) 
        {
        colIndex++;
        }
    if ( arr[rowIndex][colIndex] != 'p' )       
        {
        rowIndex++;
        }
    }

if ( arr[rowIndex][colIndex] != 'p' ) 
    {
    return false; 
    }
row = rowIndex;
col = colIndex; 
return true; 

}

/////////////// checkForPatchSize /////////////////////////////////////////
// Requirements: a 2D array of garden, and the coordinates of the start  //
//                 of a patch.  (Gotten from findPatch)                  //
// Returns an int, which is the size of the patch found                  //
// All p's or pumpkins are changed to x's so that they are not used      // 
//  multiple times.                                                  //
/////////////////////////////////////////////////////////////////////////// 
int checkForPatchSize ( char arr[][MAX_COL], int numOne, int numTwo ) 
{
int index = 0;  


if ( arr[numOne][numTwo] == 'p' ) 
    {
    index++; 
    arr[numOne][numTwo] = '0';

        // Check Above
        index += checkForPatchSize ( arr, numOne - 1, numTwo );

        // Check to Left
        index += checkForPatchSize ( arr, numOne, numTwo - 1 ); 

        // Check Below
        index += checkForPatchSize ( arr, numOne + 1, numTwo ); 

        // Check to Right 
        index += checkForPatchSize ( arr, numOne, numTwo + 1 ); 

    return index; 
    }

return 0;


    


}
/////////////// sort //////////////////////////////////////////////////////
// Requirements: an integer array, and the size of it (amount of         //
//               numbers in it).                                         //
//                                                                       //
// Sorts an array from smalles to largest numbers                        //
/////////////////////////////////////////////////////////////////////////// 
void sort ( int arr[], int size ) 
{
int index = 0; 
bool changeMade = true; 
    
while ( changeMade == true ) 
    {
    changeMade = false;
    for ( index = 0; index < size - 1; index++ ) 
        {
        if ( arr[index] > arr[index+1] ) 
            {
            int temp = arr[index]; 
            arr[index] = arr[index+1];
            arr[index+1] = temp;
            changeMade = true; 
            } 
        }

    }
}
4

1 回答 1

0

好的,在阅读您的代码后,我看到了您的方法。一般来说,我会从视觉的角度来解决这个问题。实际上,您的代码应该可以正常工作,并且是一个非常优雅的解决方案。你的算法的唯一弱点是它每次移动时都会迭代同一个补丁。例如,当它向上移动时,它会向下检查。避免冗余是最佳算法的最可靠标志,但就您部署算法的小规模而言,它不一定是最佳的。

在某种程度上,您的代码的递归性质使它非常漂亮,因为它像消失的小火花一样穿过南瓜补丁,我真的很喜欢。递归是我不经常打扰自己的事情,主要是因为我不递归思考,但是在花了一点时间围绕你的算法思考之后,我确实看到了它在这种情况下的价值。我很想看到该算法与动态视觉效果一起工作。

至于你的算法的准确性,我无法想象它会以任何方式无法正确计算南瓜,因为它的功能是在挑选的南瓜周围产生一个小波,算法在其中重复自身,有效地通过补丁传播直到它都被计算在内。正如我所说,您的算法的唯一缺点是,如果您没有以某种方式将南瓜标记为已找到(它会检查调用它的位置),它将陷入无限循环。除此之外,我只能说你提出了一个很好的解决方案,你的怀疑几乎完全是错误的。在这方面使用递归算法是一个很好的选择,因为它不需要很长的案例列表来“计数”;它只是跳到相邻的位置,并以完整的计数返回自身。

于 2013-09-25T03:02:49.983 回答