C语言中的连接字符串模式

我想实现连接字符串模式。下面是你看到的充满 非零即1被连接并形成类似“U”的图案，因此其位置也以“U”连接形状打印。 最后一列还有两个1连接。 像这样，我想要所有由非零元素填充的位置，如果它们是连接的，则需要连接模式中的序列。 我尝试了一个代码，但在某个点上卡住了。 请提供最佳解决方案。 谢谢

void main（）
{
INTA[10][10]，i，j；
对于（i=0；i0）
{
printf（“%d（%d，%d）”，a[i][j]，i，j）；
}
}
}
预期产量
0   0   0   0   0
1   0   1   0   0
1   0   1   0   1
1   1   1   0   1
0   0   0   0   0
连接的字符串是：1（1,0）、1（2,0）、1（3,0）1（3,1）、1（3,2）、1（2,2）、2（1,2）
连接的字符串为：1（2,5），1（3,5）

使用广度优先搜索或深度优先搜索。我正在使用的

为了保存模式，我使用了一个动态数组（指向指针的指针），

referenceToPatterns[]

，来存储元素的位置。如果我知道新的动态数组不适合现有的模式，我将启动它

算法

--遍历元素，如果您找到

1

，并确认您有一个可以容纳的现有模式，然后将位置放置在该模式中，否则我将启动一个新的动态数组，希望这将是新模式的根

#include "stdio.h"
#include "math.h"
#include "stdlib.h"
int insertIntoPattern(int* element, int* referenceToPatterns[],int NO_OF_ROWS,int     NO_OF_COLS);
int main()
{
int array[][5] = {  {0,0,0,0,0}, {1,0,1,0,0}, {1,0,1,0,1}, {1,1,1,0,1}, {0,0,0,0,0}};
const int NO_OF_ROWS = sizeof(array)/ sizeof(array[0]);
const int NO_OF_COLS = sizeof(array[0])/ sizeof(array[0][0]);

int sizeOfreferenceToPatterns = floor(( NO_OF_ROWS * NO_OF_COLS ) / 2);
// this is half the size of elements in the 2D arrays because at most you can have patterns half that of elements logically thinking 
int* referenceToPatterns[sizeOfreferenceToPatterns];
int initialization = 0;

do
{
    // just making sure everything is NULL
    referenceToPatterns[initialization++] = NULL;
}while(initialization < sizeOfreferenceToPatterns);

// I am Traversing

for(int i = 0; i < NO_OF_ROWS ; i++)
{
    for (int j = 0; j < NO_OF_COLS ; ++j)
    {
        if(array[i][j] == 1)
        {
            int element[] = { i, j};
            insertIntoPattern(element, referenceToPatterns,NO_OF_ROWS,NO_OF_COLS);
        }
    }
}

initialization = 0;
mergePatterns(referenceToPatterns);
}

int mergePatterns(int* referenceToPatterns[])
{

}
int insertIntoPattern(int* element,int* referenceToPatterns[],int NO_OF_ROWS,int NO_OF_COLS)
{
bool status = false;
bool thisPattern = false;
if(referenceToPatterns[0] == NULL) // this means i have just started to recognize patterns
{
    referenceToPatterns[0] = (int *)calloc(NO_OF_COLS * NO_OF_ROWS,sizeof(int));
    referenceToPatterns[0][0] = element[0];
    referenceToPatterns[0][1] = element[1];
}
else 
{
    int sizeOfreferenceToPatterns = floor((NO_OF_ROWS*NO_OF_COLS)/2);
    // in case every element is `1`
    int i,j;
    for(i =0 ; i < sizeOfreferenceToPatterns ; i++)
    {
        if(referenceToPatterns[i] != NULL)
        {
            for(j=0; referenceToPatterns[i][j] != 0; j=j+2)
            {
                switch(1)
                {       
                    // this is how i see if certain element can fit into existing pattern
                    case 1:
                        if((element[0] - 1) >= 0)
                        {
                            if( referenceToPatterns[i][j] == (element[0] - 1) && referenceToPatterns[i][j+1] == element[1])
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                    case 2:
                        if((element[0] + 1) < NO_OF_ROWS)
                        {
                            if( referenceToPatterns[i][j] == (element[0] + 1) && referenceToPatterns[i][j+1] == element[1])
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                    case 3:
                        if((element[1] - 1) >= 0)
                        {
                            if( referenceToPatterns[i][j] == element[0] && referenceToPatterns[i][j+1] == (element[1] -1))
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                    case 4:
                        if((element[1] + 1) < NO_OF_COLS)
                        {
                            if( referenceToPatterns[i][j] == element[0] && referenceToPatterns[i][j+1] == (element[1] + 1))
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                //printf("in the inner for loop\n");
                }
            }
            if(thisPattern == true)
            {
                referenceToPatterns[i][j] = element[0];
                referenceToPatterns[i][j+1] = element[1];   
            }
        }
        else break;
    }
    if(thisPattern == false)
    {
        // if the element cannot fit into one, assume that they behave as a root for a new pattern.
        referenceToPatterns[i] = (int *)calloc(NO_OF_COLS * NO_OF_ROWS,sizeof(int));
        referenceToPatterns[i][0] = element[0];
        referenceToPatterns[i][1] = element[1];
    }
}
}

--因为您正在遍历单个元素，所以有一个变化，即某些元素将进入多个现有的模式

--合并共享公共有序对的模式

这是我通过运行下面的代码得到的

referenceToPattern[0]={{1,0}、{2,0}、{3,0}、{3,1}、{3,2}

referenceToPattern[1]={{1,2}，{2,2}，{3,2}

referenceToPattern[2]={{2,4}，{3,4}

由于模式0、1共享{3,2}，因此它们构成单个模式

#include "stdio.h"
#include "math.h"
#include "stdlib.h"
int insertIntoPattern(int* element, int* referenceToPatterns[],int NO_OF_ROWS,int     NO_OF_COLS);
int main()
{
int array[][5] = {  {0,0,0,0,0}, {1,0,1,0,0}, {1,0,1,0,1}, {1,1,1,0,1}, {0,0,0,0,0}};
const int NO_OF_ROWS = sizeof(array)/ sizeof(array[0]);
const int NO_OF_COLS = sizeof(array[0])/ sizeof(array[0][0]);

int sizeOfreferenceToPatterns = floor(( NO_OF_ROWS * NO_OF_COLS ) / 2);
// this is half the size of elements in the 2D arrays because at most you can have patterns half that of elements logically thinking 
int* referenceToPatterns[sizeOfreferenceToPatterns];
int initialization = 0;

do
{
    // just making sure everything is NULL
    referenceToPatterns[initialization++] = NULL;
}while(initialization < sizeOfreferenceToPatterns);

// I am Traversing

for(int i = 0; i < NO_OF_ROWS ; i++)
{
    for (int j = 0; j < NO_OF_COLS ; ++j)
    {
        if(array[i][j] == 1)
        {
            int element[] = { i, j};
            insertIntoPattern(element, referenceToPatterns,NO_OF_ROWS,NO_OF_COLS);
        }
    }
}

initialization = 0;
mergePatterns(referenceToPatterns);
}

int mergePatterns(int* referenceToPatterns[])
{

}
int insertIntoPattern(int* element,int* referenceToPatterns[],int NO_OF_ROWS,int NO_OF_COLS)
{
bool status = false;
bool thisPattern = false;
if(referenceToPatterns[0] == NULL) // this means i have just started to recognize patterns
{
    referenceToPatterns[0] = (int *)calloc(NO_OF_COLS * NO_OF_ROWS,sizeof(int));
    referenceToPatterns[0][0] = element[0];
    referenceToPatterns[0][1] = element[1];
}
else 
{
    int sizeOfreferenceToPatterns = floor((NO_OF_ROWS*NO_OF_COLS)/2);
    // in case every element is `1`
    int i,j;
    for(i =0 ; i < sizeOfreferenceToPatterns ; i++)
    {
        if(referenceToPatterns[i] != NULL)
        {
            for(j=0; referenceToPatterns[i][j] != 0; j=j+2)
            {
                switch(1)
                {       
                    // this is how i see if certain element can fit into existing pattern
                    case 1:
                        if((element[0] - 1) >= 0)
                        {
                            if( referenceToPatterns[i][j] == (element[0] - 1) && referenceToPatterns[i][j+1] == element[1])
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                    case 2:
                        if((element[0] + 1) < NO_OF_ROWS)
                        {
                            if( referenceToPatterns[i][j] == (element[0] + 1) && referenceToPatterns[i][j+1] == element[1])
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                    case 3:
                        if((element[1] - 1) >= 0)
                        {
                            if( referenceToPatterns[i][j] == element[0] && referenceToPatterns[i][j+1] == (element[1] -1))
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                    case 4:
                        if((element[1] + 1) < NO_OF_COLS)
                        {
                            if( referenceToPatterns[i][j] == element[0] && referenceToPatterns[i][j+1] == (element[1] + 1))
                            {
                                thisPattern = true; 
                                break;
                            }
                        }
                //printf("in the inner for loop\n");
                }
            }
            if(thisPattern == true)
            {
                referenceToPatterns[i][j] = element[0];
                referenceToPatterns[i][j+1] = element[1];   
            }
        }
        else break;
    }
    if(thisPattern == false)
    {
        // if the element cannot fit into one, assume that they behave as a root for a new pattern.
        referenceToPatterns[i] = (int *)calloc(NO_OF_COLS * NO_OF_ROWS,sizeof(int));
        referenceToPatterns[i][0] = element[0];
        referenceToPatterns[i][1] = element[1];
    }
}
}

#包括“stdio.h”
#包括“math.h”
#包括“stdlib.h”
int insertIntoPattern（int*元素，int*引用模式[]，int行的int NO，int列的int NO）；
int main（）
{
int数组[][5]={{0,0,0,0,0}，{1,0,1,0,0}，{1,0,1,0,1}，{1,1,1,0,1}，{0,0,0,0}；
const int NO_OF_ROWS=sizeof（数组）/sizeof（数组[0]）；
const int NO_OF_COLS=sizeof（数组[0]）/sizeof（数组[0][0]）；
int sizeOfreferenceToPatterns=floor（（行数*列数）/2）；
//这是2D数组中元素大小的一半，因为最多可以有逻辑思维元素大小的一半的模式
int*referenceToPatterns[sizeOfreferenceToPatterns]；
int初始化=0；
做
{
//只是确保一切都是空的
referenceToPatterns[initialization++]=NULL；
}while（初始化=0）
{
if（referenceToPatterns[i][j]==（元素[0]-1）&&referenceToPatterns[i][j+1]==元素[1]）
{
这个模式=真；
打破
}
}
案例2：
if（（元素[0]+1）<没有行）
{
if（referenceToPatterns[i][j]==（元素[0]+1）&&referenceToPatterns[i][j+1]==元素[1]）
{
这个模式=真；
打破
}
}
案例3：
如果（（元素[1]-1）>=0）
{
if（referenceToPatterns[i][j]==元素[0]&&referenceToPatterns[i][j+1]==（元素[1]-1））
{
这个模式=真；
打破
}
}
案例4：
if（（元素[1]+1）<没有列）
{
if（referenceToPatterns[i][j]==元素[0]&&referenceToPatterns[i][j+1]==（元素[1]+1））
{
这个模式=真；
打破
}
}
//printf（“在内部for循环中\n”）；
}
}
if（thisPattern==true）
{
参考模式[i][j]=元素[0]；
参考的