2

所以我有这个程序应该解决 C 中的一个 futoshiki 难题,它是从具有这种格式的文本文件加载的:

5
0 | 0 | 0 | 0 | 0
- - - - v - - - -
0 > 0 | 0 | 0 | 3
- - - - - - - - -
0 | 0 < 2 | 0 | 0
- - - - v - - - -
0 | 0 | 0 | 0 | 4
^ - v - - - - - -
0 | 0 | 0 | 0 | 0

其中 5 是矩阵的大小,与运算符<, >,相邻^的数字v必须满足它们施加的条件,从文件中,行上的所有字符都除以空格,例如0 |......所以我设法加载该文件,以检查它是否满足数学运算符条件,但我被困在递归函数上

我想知道的:

我是否选择了正确的方式来存储矩阵,或者我应该将数字与逻辑运算符分开?

我如何对矩阵执行递归扩展,如何在某个步骤中跟踪使用的数字(以防我不得不回溯)?

例如。假设我到达index[j][j]where j<n(size of matrix) ,从那里开始我必须减少j(“接触”)数字并检查子矩阵是否满足条件

到目前为止,这是我设法编写的代码。

在哪里 :

char **readmat(int *n); //从文件中读取矩阵,消除字符之间的空格

void print(char **mat,int n);//打印存储的矩阵

int check(char **mat,int n); //检查大小为n的矩阵的项目是否满足数学运算符

int expand (char **mat,int n,int i);//这应该是一次获取一个元素并检查是否有任何条件要满足的递归函数,如果是,则递增它

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


char **readmat(int *n);
void print(char **mat,int n);
int check(char **mat,int n); 
int expand (char **mat,int n,int i);

int main(int argc, char *argv[])
  {
  char **mat;
  int n, j;

  mat=readmat(&n);

  if(mat == NULL)
     return 1;

  if(check(mat,n)){
     print(mat,n);
  }
  else if(expand(mat,n,0)==1){
      print(mat,n);
  }
  else {
      printf("Nessuna soluzione trovata.\n");
  }

  for(j=0; j<=n;j++)
       free(mat[j]);
  free(mat);

  system("PAUSE");  
  return 0;
}

char **readmat(int *n){
     FILE *fp;
     char *line,nome[100];
     int i,j,k;
     char **mat;

     printf("Inserire il nome del file: ");
     scanf("%s",nome);
     fp=fopen(nome,"r");
     if(fp==NULL){
     printf("Errore apertura file");
     return NULL;
 }

 if(fgets(nome,100,fp)==NULL){
     printf("Formato file non valido\n");
     fclose(fp);
     return NULL;
 }
 if(sscanf(nome,"%d",n)!=1){
     printf("Errore nei parametri del file\n");
     fclose(fp);
     return NULL;    
 }

 (*n)=(((*n)*2)-1);


 mat=(char**)malloc((*n)*sizeof(char*));
 for(i=0;i<=(*n);i++)
    mat[i]=(char*)malloc((*n)*sizeof(char));

 line=(char*)malloc(2*(*n)*sizeof(char));

 i=0;

 while(i<=2*(*n) && fgets(line,2*(*n)+2,fp)!=NULL){
    j=0;
    k=0;
    while(j<=2*(*n)){
        if(line[j]!=' '){
           mat[i][k]=line[j];
           k++;
        }  
        j++;
    }
    i++;
 }   
 return mat;
 //print(mat, (*n));  
}

void print(char **mat,int n){
    int i=0,j=0;
    for (i=0; i<n; i++) {
     for (j=0; j<n; j++) {
        printf("%c", mat[i][j]);
     }
     printf("\n");
    }
}

int check(char **mat,int n) {

    int i,j;
    int k=1;

    for(i=0;i<n;i++){
        for(j=0;j<n;j++){
            if(mat[i][j]=='<'){
                if(mat[i][j-1] >= mat[i][j+1])
                    k=0;                               
            }
            else if(mat[i][j]=='>'){
                if(mat[i][j-1] <= mat[i][j+1])
                    k=0;
            }   
            else if(mat[i][j]=='^'){
                if(mat[i-1][j] >= mat[i+1][j])
                    k=0;    
            }
            else if(mat[i][j]=='v'){
                if(mat[i-1][j] <= mat[i+1][j])
                    k=0;                      
            }                            
        }
    }
    return k;                                
}
int expand (char **mat,int n,int i){

    int j=i/n;
    int k=i%n;
    int p;

    if(i>=n*n){

        return 1;
    }       
    else{
        if((mat[j][k]>47)&&(mat[j][k]<58)){
            if(mat[j][k]=='0'){     
                expand(mat,n,i+2);
            }   
            for (p=(mat[j][k]-48); p<(10-(mat[j][k]-48)); p++) {              
                mat[j][k]=48+p;                        
                if (check(mat,i)) {
              if (expand(mat, n, i+2)) {
                   return 1;
                    }
                }
            }
            i-=2;
            mat[j][k]='0';
        }
    }           
    return 0;
}

示例的解决方案:如您所见,逻辑条件区域明显满足

0 | 0 | 1 | 0 | 0
- - - - v - - - - 
1 > 0 | 0 | 0 | 3
- - - - - - - - - 
0 | 0 < 2 | 0 | 0
- - - - v - - - - 
0 | 1 | 0 | 0 | 4
^ - v - - - - - - 
1 | 0 | 0 | 0 | 0
4

2 回答 2

5

存储矩阵的方式应该无关紧要。你可以随心所欲地存储它,只要你能轻松获取/设置每个点的数值,并评估操作者是否满意。

非常广泛地,您可以使用如下算法来解决此类问题:

//returns true if this function solved the puzzle, false otherwise.
//gameData will be changed to the solved form of the puzzle if a solution exists, or remain unchanged if no solution exists.
//(so, whatever language you're using, ensure gameData is passed by reference here)
bool solve(gameData){
    if (!isValid(gameData)){return false;}  //oops, puzzle is unsolvable!
    if (isComplete(gameData)){return true;} //puzzle is already solved; no further modification needed.

    //choose a spot on the game board that hasn't been filled in yet.
    int x;
    int y;
    getEmptySpot(gameData, &x, &y);

    //iterate through all the possible values that could go into the empty spot.
    //you don't need anything fancy here to generate legal values for i;
    //if you accidentally supply an invalid value, then isValid()
    //will notice in the next solve() call.
    for (int i = 1; i <= 5; i++){
        //try putting i in the empty spot.
        setValue(gameData, x, y, i);
        if (solve(gameData)){ //putting i in the spot led to a solution!
            return true;
        }
    }
    //didn't find a solution :(
    //return gameData to its original state.
    setValue(gameData, x, y, 0);
    return false;
}

该算法进行强力递归搜索,尝试每个点的所有可能值,如果它进入非法状态则回溯。在最坏的情况下,它以指数时间运行,但在实践中,isValid()一开始的调用会使任何明显不可行的分支短路,因此对于 5x5 输入,它应该相当快地完成。

isValid、isComplete、getEmptySpot 和 setValue 的实现将取决于您如何定义 gameData。

isValid应该检查游戏数据是否处于非法状态 - 在您的情况下,它应该检查所有大于比较是否正确,并检查每个数字在每一行和每一列中只出现一次。这些检查应该忽略值为 0 的点,因为它们只是一个占位符,意思是“尚未填充”。

isComplete应该检查看没有斑点有“尚未填充”占位符。(isValid(gameData) && isComplete(gameData))意味着 gameData 已解决。

getEmptySpot应该找到一个尚未填充的位置。如果您担心速度,它应该找到一个可以合法输入的数值最少的位置。这将大大减少搜索树的宽度。

最后,setValue应将给定点设置为给定值。

于 2012-02-09T19:50:58.960 回答
0

我会

  1. 删除矩阵大小。通过阅读矩阵本身很明显
  2. 删除管道和其他字符,只留下空格
  3. 在矩阵之后添加运算符,采用特殊的“编码”格式
  4. 单个函数可以采用规则并尝试求解矩阵

矩阵示例:

0 0 0 0 0
0 0 0 0 3
0 0 2 0 0
0 0 0 0 4
0 0 0 0 0 
--
1,3>2,3
2,1>2,2
3,2<3,3
3,3>4,3
4,1<5,1
4,2>5,2

--开始规则之后,意思很清楚(至少对我来说):第 1 行第 3 列的值必须大于第 2 行第 3 列的值。

等等

关于求解器,我将从以下开始:

  1. 在矩阵中搜索是否存在涉及 2 必须大于另一个单元格的单元格的规则。如果是,您可以立即在另一个单元格中插入 1
  2. 对整个矩阵重复第 1 点,这样您将得到一个新的、部分求解的矩阵作为起点
  3. 与上述规则“小于”的 4s 相同。您可以在相关单元格中输入 5
  4. 现在搜索是否有一行(或列)填充了 4 个数字。如果是这样,第 5 个数字是显而易见的。

当您完成前面的步骤后,您有一个部分(如果幸运的话可能完全)解决了矩阵,那么您必须编写一个核心函数来尝试每种组合,但要考虑动态规则(文件中的那些)和静态规则(那些制作游戏的人)。

于 2012-02-09T14:10:34.027 回答