結果

問題 No.2838 Diagonals
コンテスト
ユーザー Butterflv
提出日時 2024-08-10 12:45:12
言語 C++23
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 11 ms / 2,000 ms
コード長 2,909 bytes
コンパイル時間 3,177 ms
コンパイル使用メモリ 250,896 KB
実行使用メモリ 5,376 KB
最終ジャッジ日時 2024-08-10 12:45:16
合計ジャッジ時間 4,085 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 20
権限があれば一括ダウンロードができます

ソースコード

diff # 

// #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;

#ifndef ATCODER_DSU_HPP
#define ATCODER_DSU_HPP 1

#include <algorithm>
#include <cassert>
#include <vector>

namespace atcoder {

// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
  public:
    dsu() : _n(0) {}
    dsu(int n) : _n(n), parent_or_size(n, -1) {}

    int merge(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        int x = leader(a), y = leader(b);
        if (x == y) return x;
        if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
        parent_or_size[x] += parent_or_size[y];
        parent_or_size[y] = x;
        return x;
    }

    bool same(int a, int b) {
        assert(0 <= a && a < _n);
        assert(0 <= b && b < _n);
        return leader(a) == leader(b);
    }

    int leader(int a) {
        assert(0 <= a && a < _n);
        if (parent_or_size[a] < 0) return a;
        return parent_or_size[a] = leader(parent_or_size[a]);
    }

    int size(int a) {
        assert(0 <= a && a < _n);
        return -parent_or_size[leader(a)];
    }

    std::vector<std::vector<int>> groups() {
        std::vector<int> leader_buf(_n), group_size(_n);
        for (int i = 0; i < _n; i++) {
            leader_buf[i] = leader(i);
            group_size[leader_buf[i]]++;
        }
        std::vector<std::vector<int>> result(_n);
        for (int i = 0; i < _n; i++) {
            result[i].reserve(group_size[i]);
        }
        for (int i = 0; i < _n; i++) {
            result[leader_buf[i]].push_back(i);
        }
        result.erase(
            std::remove_if(result.begin(), result.end(),
                           [&](const std::vector<int>& v) { return v.empty(); }),
            result.end());
        return result;
    }

  private:
    int _n;
    // root node: -1 * component size
    // otherwise: parent
    std::vector<int> parent_or_size;
};

}  // namespace atcoder

#endif  // ATCODER_DSU_HPP


int N,M;
char S[509][509];
const int dh[]={0,0,1,-1},dw[]={1,-1,0,0};

int main(){
  ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  cout<<fixed<<setprecision(15);

  long long ans=1LL;
  const long long MOD=998244353LL;

  cin>>N>>M;
  for(int i=0;i<N;i++)for(int j=0;j<M;j++)cin>>S[i][j];
  atcoder::dsu uf(N*M);
  for(int h=0;h<N;h++)for(int w=0;w<M;w++){
    if(S[h][w]=='.')continue;
    if(h==0||w==0)ans*=4;
    else if(uf.same((h-1)*M+w, h*M+w-1))ans*=2;
    else ans*=4;
    ans%=MOD;
    if(h==0&&w==0)continue;
    else if(h==0){if(S[h][w-1]=='#')uf.merge(h*M+w, h*M+w-1);}
    else if(w==0){if(S[h-1][w]=='#')uf.merge(h*M+w, (h-1)*M+w);}
    else{
      if(S[h-1][w]=='#')uf.merge(h*M+w, (h-1)*M+w);
      if(S[h][w-1]=='#')uf.merge(h*M+w, h*M+w-1);
    }
  }
  cout<<ans%MOD<<endl;
}
0