L36有效的数独

最新推荐文章于 2022-04-25 11:32:05 发布

原创最新推荐文章于 2022-04-25 11:32:05 发布 · 157 阅读

0 ·

CC 4.0 BY-SA版权

JAVA练练手同时被 2 个专栏收录

36 篇文章

订阅专栏

LeetCode刷题

35 篇文章

订阅专栏

本文介绍了一种高效验证数独是否有效的算法实现。通过优化循环结构，将原本分开验证行、列、块的方法整合到一个循环中，显著提高了验证效率。文章详细解释了如何使用Set数据结构来检查重复项，并提供了完整的代码示例。

思路：

分别验证行，列，块，下面是我的代码，每次做一件事情，所以我用了三次独立的for，这样效率不高。于是改了一个思路

public static boolean isValidSudoku(char[][] board) {
        boolean flag=true;
        for(int i=0;i<board[0].length;i++){
            flag=isValid(board[i]);
            if(flag==false){
                break;
            }
        }
        if(flag==false){
        	return flag;
        }
        for(int i=0;i<board[0].length;i++){
            char[] col=new char[9];
            for(int j=0;j<9;j++){
            	char n = board[j][i];
                col[j]=n;
            }
            flag=isValid(col);
            if(flag==false){
                break;
            }
        }
        if(flag==false){
        	return flag;
        }
        for(int i=0;i<9;i+=3){
            char[] block=new char[9];
            for(int j=0;j<9;j+=3){
                block[0]=board[i][j];
                block[1]=board[i+1][j];
                block[2]=board[i+2][j];
                block[3]=board[i][j+1];
                block[4]=board[i+1][j+1];
                block[5]=board[i+2][j+1];
                block[6]=board[i][j+2];
                block[7]=board[i+1][j+2];
                block[8]=board[i+2][j+2];
                flag=isValid(block);
                if(flag==false){
                    break;
                }
            }
            if(flag==false){
                    break;
            }
        }
        return flag;
        
    }
    public static boolean isValid(char[] arr){
        ArrayList<Character> al=new ArrayList<Character>();
        for(int i=0;i<arr.length;i++){
            if(arr[i]!='.'){
                al.add(arr[i]);
            }
        }
        HashSet<Character> hs=new HashSet<Character>();
        int i=0;
        for(char c:al){
            if(i>=al.size()){
                break;
            }
            hs.add(c);
        }
        if(al.size()!=hs.size()){
            return false;
        }else{
            return true;
        }
    }

新的思路是这样，一次循环，根据下标，属于行的放入行，列的放入列，快的放入块。一次大循环，都做完，用Set比较好：

class Solution {
    public boolean isValidSudoku(char[][] board) {
        if(board==null||board.length!=9||board[0].length!=9){
            return false;
        }
        Set<Character> row=new HashSet<Character>();
        Set<Character> col=new HashSet<Character>();
        boolean flag=true;
        for(int i=0;i<9;i++){
            row.clear();
            col.clear();
            for(int j=0;j<9;j++){
                if(i%3==0&&j%3==0){
                	flag= blockCheck(board,i,j);
                	if(flag==false){
                		return flag;
                	}
                }  
            	
                 if(board[i][j]!='.'){
                    if(row.contains(board[i][j])){
                    	flag= false;
                    	if(flag==false){
                    		return flag;
                    	}
                    }else{
                        row.add(board[i][j]);
                    }
                 }
                char n=board[j][i];   	
                if(board[j][i]!='.'){
                    if(col.contains(board[j][i])){
                    	flag= false;
                    	if(flag==false){
                    		return flag;
                    	}
                    }else{
                        col.add(board[j][i]);
                    }                    
                }
                 
            }
            }
        return flag;
        }
    public boolean blockCheck(char[][] board,int row,int col){
        Set<Character> block=new HashSet<Character>();
        for(int i=row;i<row+3;i++){
            for(int j=col;j<col+3;j++){
                if(board[i][j]!='.'){
                     if(block.contains(board[i][j])){
                        return false;
                    }else{
                        block.add(board[i][j]);
                    }                   
                }
            }
        }
        return true;
    }
}