Problem:
まるかいて

太郎君は小学生で、チラシの裏に落書きをしています。

ある時、太郎君は次のゲームを思いつきました。

n×nの格子状のマス目を書いておきます。

それぞれのマス目の初期状態は、丸印が書かれているか、書かれていないかのどちらか一方です。

これらの丸印を消したり書いたりして最終的にどの一列を見ても必ずちょうど1つのみの丸印が、どの一行を見ても必ず1つのみの丸印が存在するようにすることが目標であり、この状態にすればゲームをクリアしたことになります。

太郎君はこのゲームを思いつきましたが、太郎君はこのゲームをクリアするのに大変時間がかかってしまいます。そこで、大学生であるあなたに助けを求めました。

太郎君の兄であり大学生であるあなたの仕事は以下の通りです。

厳密な状況を考えるために、あるマス目に丸印を書き込むコスト、あるマス目にある丸印を消すコストをあなたは導き出しました。このコストを用いてこのゲームをクリアするためにかかる操作のコストを最小化するような手順を考える。
このとき、最小のコストおよびそのコストを達成するような手順を出力するプログラムを書いてください。
出力については、最小コストを達成する手順なら、どのような操作、順番でも出力してもよいものとする。

Input

n
W11 W12 .. W1n
W21 W22 .. W2n
..
Wn1 Wn2 .. Wnn
E11 E12 .. E1n
E21 E22 .. E2n
..
En1 En2 .. Enn
F1(n文字)
F2(n文字)
..
Fn(n文字)

nは太郎君の作ったマス目が一辺にいくつあるかを表す

Wijは上からi番目、左からj番目のマス目に丸印を書き込むコストを表す

Eijは上からi番目、左からj番目のマス目に書かれてある丸印を消すコストを表す

Fiは上からi番目の行のマス目の初期状態を表す

Fiの左からj文字目について

'o'のとき、上からi番目、左からj番目のマス目に丸印が書かれてあることを表す。

'.'のとき、上からi番目、左からj番目のマス目が空白であることを表す。

Constraints

1≤ n ≤ 100
1≤ Wij ≤ 1000
1≤ Eij ≤ 1000

Fiは文字列であり、その長さはnである

Fiは'o'と'.'のみで構成されている

Output

mincost
cnt
R1 C1 operate1
R2 C2 operate2
..
Rcnt Ccnt operatecnt

mincostは、太郎君のゲームをクリアするために必要な最小コストを表す。

mincostは書き込み操作、消去操作で発生するコストの総和で計算される。

cnt : mincostのコストを達成する操作を行った回数を表す

k回目(1≤k≤cnt)に実行する操作はk+2行目に記述する

k回目(1≤k≤cnt)の操作に対して

上からi番目のマス目、左からj番目のマス目に対して行ったものとすると

Rkkである。

この操作が丸印を消す操作であるならばoperatek = "erase"とせよ

この操作が丸印を書き込む操作であるならばoperatek = "write"とせよ

Rk,Ck,operatekは一行に空白区切りで出力しなければならない

丸印の書かれてあるマス目に対して丸印を記述する操作、および丸印が書かれていないマス目に対して丸印を消去する操作をした場合はWrongAnswerである

cnt個の操作にかかるコストの総和がmincostに一致しないときはWrongAnswerである

Sample Input 1

3
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
o.o
...
.o.

Output for the Sample Input 1

2
2
1 3 erase
2 3 write

上から1番目、左から3番目のマス目の丸印を消去し、
上から2番目、左から3番目のマス目に丸印を書き加えれば目標は達成できる。
このときコストは2のみしかかからず、これが最小のコストである。

Sample Input 2

4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
oooo
oooo
oooo
oooo

Output for the Sample Input 2

30
12
1 1 erase
1 2 erase
1 3 erase
2 1 erase
2 2 erase
2 4 erase
3 1 erase
3 3 erase
3 4 erase
4 2 erase
4 3 erase
4 4 erase

コスト(1+2+3+4)*3だけ消去処理をすればクリアとなります。

Sample Input 3

3
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
o..
.o.
..o

Output for the Sample Input 3

0
0

すでに目標は達成されているため、コスト及び操作回数はともに0となる。

Solution in C++11 (judge verdict: Accepted)

#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)

using namespace std;

    struct Edge{
        int src, dst, cap, cost, rev;
        Edge() {}
        Edge(int s, int d, int c, int cs, int r) : 
            src(s), dst(d), cap(c), cost(cs), rev(r) {}
    };

struct MinCostFlow{
    typedef pair<int, int> P;
    static const int INF = 100000000; 

    typedef vector<Edge> Node;
    typedef vector<Node> Graph;

    Graph G;

    MinCostFlow(int N) : G(N) {}

    void add_edge(int src, int dst, int cap, int cost){
        G[src].push_back(Edge(src, dst, cap, cost, G[dst].size()));
        G[dst].push_back(Edge(dst, src, 0, -cost, G[src].size() - 1));
    }

    int min_cost_flow(int s, int t, int f){
        int V = G.size();
        vector<int> h(V);
        vector<int> prevv(V), preve(V);
        int res = 0;
        while(f > 0){
            priority_queue<P, vector<P>, greater<P>> que;
            vector<int> dist(V, INF);
            dist[s] = 0;
            que.push(P(0, s));

            while(!que.empty()){
                P p = que.top(); que.pop();
                int v = p.second;
                if(dist[v] < p.first) continue;
                for(int i = 0; i < G[v].size(); i++){
                    Edge& e = G[v][i];
                    int ndist = dist[v] + e.cost + h[v] - h[e.dst];
                    if(e.cap > 0 && dist[e.dst] > ndist){
                        dist[e.dst] = ndist;
                        prevv[e.dst] = v;
                        preve[e.dst] = i;
                        que.push(P(ndist, e.dst));
                    }
                }
            }

            if(dist[t] == INF){
                return -1;
            }

            for(int v = 0; v < V; v++) h[v] += dist[v];

            int d = f;
            for(int v = t; v != s; v = prevv[v]){
                d = min(d, G[prevv[v]][preve[v]].cap);
            }

            f -= d;
            res += d * h[t];
            for(int v = t; v != s; v = prevv[v]){
                Edge& e = G[prevv[v]][preve[v]];
                e.cap -= d;
                G[v][e.rev].cap += d;
            }
        }
        return res;
    }

    vector<Edge> flow_edges(){
        vector<Edge> res;
        for(int i = 0; i < G.size(); i++){
            for(const auto& e : G[i]){
                if(e.cap == 0){
                    res.push_back(e);
                }
            }
        }
        return res;
    }
};

int main(){
    int N;
    while(cin >> N){
        int W[100][100];
        int E[100][100];
        REP(y, N) REP(x, N) cin >> W[y][x];
        REP(y, N) REP(x, N) cin >> E[y][x];
        string grid[100];
        REP(y, N) cin >> grid[y];

        MinCostFlow solver(N + N + 2);
        int Source = N + N;
        int Dist = Source + 1;
        REP(y, N) solver.add_edge(Source, y, 1, 0);
        REP(x, N) solver.add_edge(x + N, Dist, 1, 0);

        for(int y = 0; y < N; y++){
            for(int sx = 0; sx < N; sx++){
                int cost = 0;
                if(grid[y][sx] == '.'){
                    cost += W[y][sx];
                }
                for(int x = 0; x < N; x++){
                    if(x != sx && grid[y][x] == 'o'){
                        cost += E[y][x];
                    }
                }
                //printf("%d -> %d : %d\n", y, sx, cost);
                solver.add_edge(y, sx + N, 1, cost);
            }
        }

        int mincost = solver.min_cost_flow(Source, Dist, N);
        vector<Edge> edges = solver.flow_edges();
        vector<int> select(N);
        for(Edge e : edges){
            if(e.src < N){
                select[e.src] = e.dst - N;
            }
        }
        int count = 0;
        stringstream ss;
        int cost = 0;
        for(int y = 0; y < N; y++){
            for(int x = 0; x < N; x++){
                if(select[y] == x && grid[y][x] == '.'){
                    ss << y + 1 << " " << x + 1 << " write" << endl;
                    cost += W[y][x];
                    count++;
                }
                if(select[y] != x && grid[y][x] == 'o'){
                    ss << y + 1 << " " << x + 1 << " erase" << endl;
                    cost += E[y][x];
                    count++;
                }
            }
        }
        //assert(mincost == cost);
        cout << mincost << endl;
        cout << count << endl;
        cout << ss.str();
    }
    return 0;
}