DFS/BFS

Sudoku Killer

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

int zeroNum;
int map[9][9];
int zero[81][2];         // 存储空位坐标，dfs直接搜索这些位置

void print()
{
    for(int i = 0; i < 9; i++)
    {
        for(int j = 0; j < 9; j++)
        {
            printf("%d", map[i][j]);
            if(j==8) printf("\n");
            else printf(" ");
        }
    }
}
bool check(int cnt)                            
{
    int row = zero[cnt][0];
    int col = zero[cnt][1];
    int subRowStart = row/3 * 3;
    int subColStart = col/3 * 3;

    for(int i = 0; i < 9; i++)
    {
        if(map[row][i]==map[row][col] && i!=col)
            return false;
        if(map[i][col]==map[row][col] && i!=row)
            return false;
    }
    for(int i = subRowStart; i < subRowStart+3; i++)
    {
        for(int j = subColStart; j < subColStart+3; j++)
        {
            if(map[i][j]==map[row][col] && (i!=row || j!=col))
                return false;
        }
    }
    return true;
}
void dfs(int cnt)            // cnt代表dfs深度
{
    int row = zero[cnt][0];
    int col = zero[cnt][1];

    if(cnt > zeroNum)        // 找到可行解，打印输出
    {
        print();
        return ;
    }
    for(int k = 1; k <= 9; k++)     
    {
        map[row][col] = k;          // 枚举所有情况
        if(check(cnt))              // Sodoku合法性检查
            dfs(cnt+1);             // 递归到下一层
                             // 注意map[row][col]在递归后还原值
        map[row][col] = 0;   // 保证上层每次枚举时深层都为空值状态
    }
}
int main()
{
    int num = 0;
    char s[2];
    while(scanf("%s", s)!=EOF)    
    {
        zeroNum = 0;
        memset(map, 0, sizeof(map));
        memset(zero, 0, sizeof(zero));

        if(s[0] == '?')
        {
            zero[++zeroNum][0] = 0;
            zero[zeroNum][1] = 0;
            map[0][0] = 0;
        }
        else
            map[0][0] = s[0] - '0';

        for(int i = 0; i < 9; i++)
        {
            for(int j = 0; j < 9; j++)
            {
                if(i || j)
                {
                    scanf("%s", s);
                    if(s[0] == '?')
                    {
                        zero[++zeroNum][0] = i;
                        zero[zeroNum][1] = j;
                        map[i][j] = 0;
                    }
                    else
                        map[i][j] = s[0]-'0';
                }
            }
        }

        if(num++) printf("\n");     // 测试用例间空行
        dfs(1);
    }
    return 0;
}

 

Oil Deposits

#include <queue>
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
#define N 102

int cnt;
int m, n;

char map[N][N];
int flag[N][N];

int x[8] = {-1,0,1,1,1,0,-1,-1};
int y[8] = {-1,-1,-1,0,1,1,1,0};
int ii, jj;

struct Block
{
    int row, col;
};

bool check(int i, int j)
{
    if(i>=0 && i<m && j>=0 && j<n)
        return true;
    else return false;
}
void dfs(int i, int j)
{
    flag[i][j] = 1;
    for(int k = 0; k < 8; k++)
    {
        ii = i + x[k];
        jj = j + y[k];
        if(check(ii, jj) && map[ii][jj]=='@' && flag[ii][jj]==0)
            dfs(ii, jj);
    }
}
void bfs(int i, int j)
{
    Block next, cur;
    next.row = i;
    next.col = j;
    queue<Block> q;
    q.push(next);

    while(!q.empty())
    {
        cur = q.front();
        q.pop();
        flag[cur.row][cur.col] = 1;

        for(int i = 0; i < 8; i++)
        {
            ii = cur.row + y[i];
            jj = cur.col + x[i];
            if(check(ii, jj))
            {
                if(map[ii][jj]=='@' && flag[ii][jj]==0)
                {
                    next.row = ii;
                    next.col = jj;
                    q.push(next);
                }
            }
        }
    }
}
int main()
{
    int i, j;
    while(scanf("%d%d", &m, &n) && m && n)
    {
        for(i = 0; i < m; i++)
        {
            for(j = 0; j < n; j++)
                cin >> map[i][j];
        }
        memset(flag, 0, sizeof(flag));
        cnt = 0;
        for(i = 0; i < m; i++)
        {
            for(j = 0; j < n; j++)
            {
                if(map[i][j]=='@' && flag[i][j]==0)
                {
                    // dfs(i, j);
                    // bfs(i, j);
                    cnt++;
                }
            }
        }
        printf("%d\n", cnt);
    }
}