結果

問題 No.421 しろくろチョコレート
ユーザー kkkkkk
提出日時 2024-12-04 18:41:15
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 5 ms / 2,000 ms
コード長 3,845 bytes
コンパイル時間 1,121 ms
コンパイル使用メモリ 92,556 KB
実行使用メモリ 5,248 KB
最終ジャッジ日時 2024-12-04 18:41:18
合計ジャッジ時間 2,948 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 AC 3 ms
5,248 KB
testcase_02 AC 2 ms
5,248 KB
testcase_03 AC 2 ms
5,248 KB
testcase_04 AC 2 ms
5,248 KB
testcase_05 AC 2 ms
5,248 KB
testcase_06 AC 2 ms
5,248 KB
testcase_07 AC 2 ms
5,248 KB
testcase_08 AC 2 ms
5,248 KB
testcase_09 AC 2 ms
5,248 KB
testcase_10 AC 2 ms
5,248 KB
testcase_11 AC 2 ms
5,248 KB
testcase_12 AC 2 ms
5,248 KB
testcase_13 AC 1 ms
5,248 KB
testcase_14 AC 2 ms
5,248 KB
testcase_15 AC 1 ms
5,248 KB
testcase_16 AC 4 ms
5,248 KB
testcase_17 AC 4 ms
5,248 KB
testcase_18 AC 3 ms
5,248 KB
testcase_19 AC 2 ms
5,248 KB
testcase_20 AC 3 ms
5,248 KB
testcase_21 AC 3 ms
5,248 KB
testcase_22 AC 2 ms
5,248 KB
testcase_23 AC 2 ms
5,248 KB
testcase_24 AC 2 ms
5,248 KB
testcase_25 AC 2 ms
5,248 KB
testcase_26 AC 2 ms
5,248 KB
testcase_27 AC 2 ms
5,248 KB
testcase_28 AC 2 ms
5,248 KB
testcase_29 AC 2 ms
5,248 KB
testcase_30 AC 2 ms
5,248 KB
testcase_31 AC 4 ms
5,248 KB
testcase_32 AC 2 ms
5,248 KB
testcase_33 AC 3 ms
5,248 KB
testcase_34 AC 2 ms
5,248 KB
testcase_35 AC 2 ms
5,248 KB
testcase_36 AC 2 ms
5,248 KB
testcase_37 AC 3 ms
5,248 KB
testcase_38 AC 4 ms
5,248 KB
testcase_39 AC 2 ms
5,248 KB
testcase_40 AC 3 ms
5,248 KB
testcase_41 AC 2 ms
5,248 KB
testcase_42 AC 1 ms
5,248 KB
testcase_43 AC 2 ms
5,248 KB
testcase_44 AC 3 ms
5,248 KB
testcase_45 AC 1 ms
5,248 KB
testcase_46 AC 2 ms
5,248 KB
testcase_47 AC 3 ms
5,248 KB
testcase_48 AC 3 ms
5,248 KB
testcase_49 AC 2 ms
5,248 KB
testcase_50 AC 2 ms
5,248 KB
testcase_51 AC 4 ms
5,248 KB
testcase_52 AC 2 ms
5,248 KB
testcase_53 AC 2 ms
5,248 KB
testcase_54 AC 2 ms
5,248 KB
testcase_55 AC 1 ms
5,248 KB
testcase_56 AC 2 ms
5,248 KB
testcase_57 AC 2 ms
5,248 KB
testcase_58 AC 3 ms
5,248 KB
testcase_59 AC 2 ms
5,248 KB
testcase_60 AC 5 ms
5,248 KB
testcase_61 AC 4 ms
5,248 KB
testcase_62 AC 2 ms
5,248 KB
testcase_63 AC 2 ms
5,248 KB
testcase_64 AC 2 ms
5,248 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <vector>
#include <queue>
#include <math.h>
#include <iostream>
#include <algorithm>
using namespace std;

#define rep(i, S, E) for(int i=(S); i<(E); i++)

struct Edge{
    int to;
    int cap;
    int rev;
};

struct Dinic{
    
    vector<vector<Edge>> G;
    vector<int> levels;
    vector<int> iters;
    const long long INF = 1<<30;
    int n;
    
    Dinic(){ ; }
    Dinic(int _n){
        G.reserve(_n);
        levels.resize(_n, 0);
        iters.resize(_n, 0);
        n = _n;
    }
    
    void set_graph(int from, int to, int cap){
        Edge e = {to, cap, (int)G[to].size()};
        G[from].emplace_back(e);
        e = {from, 0, (int)G[from].size()-1};
        G[to].emplace_back(e);
        return;
    }
    
    void bfs(int s){
        fill(levels.begin(), levels.end(), -1);
        queue<int> Q;
        Q.push(s);
        levels[s] = 0;
        
        while (!Q.empty()){
            int v = Q.front();
            Q.pop();
            
            for (Edge& e : G[v]){
                
                if (e.cap > 0 && levels[e.to] < 0){
                    levels[e.to] = levels[v] + 1;
                    Q.push(e.to);
                }
            }
        }
        
        return;
    }
    
    int dfs(int v, int t, int f){
        if (v == t){
            return f;
        }
        
        for (int& i=iters[v]; i<G[v].size(); i++){
            Edge& e = G[v][i];
            if (e.cap > 0 && levels[e.to] > levels[v]){
                int _f = dfs(e.to, t, min(f, e.cap));
                if (_f > 0){
                    e.cap -= _f;
                    G[e.to][e.rev].cap += _f;
                    return _f;
                }
            }
        }
        
        return 0;
    }
    
    int execute(int s, int t){
        int flow = 0;
        
        while(true){
            bfs(s);
            
            if(levels[t] < 0){
                return flow;
            }
            
            fill(iters.begin(), iters.end(), 0);
            
            while(true){
                int f = dfs(s, t, INF);
                if (f > 0){
                    flow +=  f;
                }else{
                    break;
                }
            }
            
        }
        return 0;
    }
    
    
    
};
  
int N, M;
char B[50][50];

bool isin(int x, int y){
    if (0 <= x && x < N){
        if (0 <= y && y < M){
            return true;
        }
    }
    return false;
}

int main() {
    cin >> N >> M;
    rep(i, 0, N){
        rep(j, 0, M){
            cin >> B[i][j];
        }
    }
    
    Dinic dinic(N*M+2);
    
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int w_cnt = 0, b_cnt = 0;
    
    rep(i, 0, N){
        rep(j, 0, M){
            if (B[i][j] != '.'){
                
                if ((i%2==0 && j%2==0) || (i%2==1 && j%2==1)){
                    w_cnt++;
                    dinic.set_graph(N*M, M*i+j, 1);
                    
                    rep(k, 0, 4){
                        if (isin(i+dy[k], j+dx[k])){
                            if (B[i+dy[k]][j+dx[k]] != '.'){
                                int from = M * i + j;
                                int to = M * (i+dy[k]) + (j+dx[k]);
                                dinic.set_graph(from, to, 1);
                            }
                        }
                    }
                    
                }else{
                    b_cnt++;
                    dinic.set_graph(M*i+j, N*M+1, 1);
                }
            }
        }
    }
    
    int f = dinic.execute(N*M, N*M+1);
    
    int answer = 100 * f;
    w_cnt -= f; b_cnt -= f;
    
    while (w_cnt && b_cnt){
        answer += 10;
        w_cnt--; b_cnt--;
    }
    
    if (w_cnt + b_cnt > 0) answer += (w_cnt + b_cnt);
    
    cout << answer << endl;
    
    return 0;
}
0