C 如何避免在这个宾果游戏程序中出现TLE？

我正在用C写一个宾果游戏程序，它有“时间限制” 超过“当在线评委给我巨大的宾果游戏板时，比如256*256板1人或150*150板6人。如何优化我的代码以避免TLE的发生？（关于蹩脚英语的sry）

我的程序得到所有的名字和电路板，当给它一个新的数字时，它会扫描每一块电路板并标记数字。然后检查玩家是否在必要时得到宾果。我试着增加尽可能多的休息时间；为了减少循环时间，我尽可能地使用它，但它仍然运行了1070ms

#include <stdio.h>

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    char players[n][64];    
    int board[n][m][m]; 
    for(int i=0;i<n;i++){            //input every player's name & board
        scanf("%s",&players[i]);
        for(int j=0;j<m;j++){
            for(int k=0;k<m;k++){
                scanf("%d",&board[i][j][k]);
            }
        }
    }
    int number;
    int foundx, foundy;
    int ifBreak = 0;
    int sum;
    int winNumber;
    int winCount = 0;
    int winners[n];
    for(int i=0;i<m*m && winCount==0;i++){
        scanf("%d",&number);            //input the numbers chosen to be marked         
        for(int j=0;j<n;j++){
            ifBreak = 0;
            sum = 0;

            for(int k=0;k<m && ifBreak==0;k++){  //mark -1 on the number chosen
                for(int l=0;l<m;l++){
                    if(board[j][k][l] == number){
                        board[j][k][l] = -1;
                        foundx = k;
                        foundy = l;
                        ifBreak = 1;
                        break;
                    }
                }
            }
            ifBreak = 0;

            //inspect horizontal line
            for(int k=0;k<m && ifBreak==0 && i>=m-1;k++){  
                if(board[j][foundx][k] != -1)
                    break;
                sum += board[j][foundx][k];
            }
            if(sum == -m){  
                winNumber = number;
                winners[winCount] = j;
                winCount++;
                ifBreak = 1;                  
            }
            sum = 0;

            //inspect vertical line
            for(int k=0;k<m && ifBreak==0 && i>=m-1;k++){  
                if(board[j][k][foundy] != -1)
                    break;
                sum += board[j][k][foundy];
            }
            if(sum == -m){  
                winNumber = number;
                winners[winCount] = j;
                ifBreak = 1;                
                winCount++;
            }
            sum = 0;

            //inspect cross line
            for(int k=0;k<m && ifBreak==0 && i>=m-1 && foundx-foundy==0;k++){  
                if(board[j][k][k] != -1)
                    break;
                sum += board[j][k][k];
            }
            if(sum == -m && ifBreak==0){
                winNumber = number;
                winners[winCount] = j;
                winCount++;
                ifBreak = 1;        
            }
            sum = 0;

            //inspect cross line
            for(int k=0;k<m && ifBreak==0 && i>=m-1 && foundx+foundy==m-1;k++){ 
                if(board[j][k][m-1-k] != -1) 
                    break;
                sum += board[j][k][m-1-k];
            }
            if(sum == -m && ifBreak==0){
                winNumber = number;
                winners[winCount] = j;
                winCount++;
                ifBreak = 1;        
            }
            sum = 0;

        }
    }
    printf("%d",winNumber);

    for(int p=0;p<winCount;p++){
        printf(" %s",players[winners[p]]);
    }
}

#包括
int main（）{
int n，m；
scanf（“%d%d”，&n，&m）；
字符播放器[n][64]；
国际板[n][m][m]；
对于（int i=0；i，您的算法提供了许多优化的机会：

for(int k=0;k<m && ifBreak==0;k++)
{
    for(int l=0;l<m;l++)
    {
        if(...)
        {
            ifBreak = 1;
            break;
        }
    }
}

然后您有多个循环，每个循环一个接一个地运行，每个循环都有自己的停止条件比较。如果您将所有这些循环组合成单个循环，则可以省去许多检查：

for(int k=0; k<m; k++)
{
    for(int l=0; l<m; l++)
    {
        // check for lines:       board[k][l]
        // check for columns:     board[l][k]
    }
    // check for first diagonal:  board[k][k]
    // check for second diagonal: board[k][m-k]
}

当然，您可以使用
m
初始化所有这些行/列/对角线

编辑：因为这些修改似乎还不够：更改电路板的表示形式！不要使用
[m][m]
数组（有效地将位置映射到数字），而是使用查找表编号来定位

这样，您就不需要在内部使用双循环（但您将保留上面的行/列/对角线字段！）：

for（int i=0；i
确保以利用缓存和缓存位置的方式迭代数组。从循环中提取计算。代码级优化（循环退出、缓存使用等）通常不是什么让你脱离TLE。你必须想出一个更有效的算法。通常，使用数学是诀窍，但不可否认，这里似乎不是这样。为了帮助你，请解释更多关于程序应该做什么的内容。输入定义是什么？给出示例，并附带所需的输出谢谢你的解决方案！它让我的程序有点快，但还不够。现在，它就像1030Ms。感谢你的建议！！@加拉博用户如果切换到C++是你的选择，那么你就可以得到一个准备好的HASMAP，使用代码< > STD:：unQuordEdMult/<代码>。如果没有，你应该咨询你最喜欢的搜索引擎准备就绪。但是，若要在C中使用实现，不能推荐一个，因为C中从不需要一个。
for(int k=0; k<m; k++)
{
    for(int l=0; l<m; l++)
    {
        // check for lines:       board[k][l]
        // check for columns:     board[l][k]
    }
    // check for first diagonal:  board[k][k]
    // check for second diagonal: board[k][m-k]
}

for(int k=0; k<m; k++)
{
    for(int l=0; l<m; l++)
    {
        if(board[k][l] == number)
        {
            if
            (
                --rows[k] == 0 || --columns[l] == 0
                || (l == k && --diagnoal1 == 0)
                || (l == m - k - 1 && --diagnoal2 == 0)
            )
            {
                // we have a winner!
                goto CurrentPlayerCompleted;
            }
        }
    }
}

for(int i = 0; i < m * m && winCount == 0; i++)
{
    for(int j = 0; j < n; j++)
    {
        // possibly need to check if the number is contained in board at all

        // possibly need to apply some hash function, for now, assuming
        // that an array for all numbers is sufficient, leaving the rest to you
        struct position pos = board[number];

        if
        (
            --rows[pos.row] == 0 || --columns[pos.column] == 0
            || (pos.column == pos.row && --diagonal1 == 0)
            || (pos.column == m - pos.row - 1 && --diagnoal2)
        )
        {
            // we have a winner!
        }
    }
}