func_code_string: #include <bits/stdc++.h>   using namespace std;   const int INF = 1000000000;   vector<int> hung(const vector<vector<int> > &A) {     int n = A.size();     int m = A[0].size();     vector<vector<long long> > a(n + 1);     a[0] = vector<long long>(m + 1);     for (int i = 0; i < n; ++i) {       a[i + 1].push_back(100LL * INF);       for (int j = 0; j < m; ++j) {         a[i + 1].push_back(A[i][j]);       }     }     vector<long long> u(n + 1), v(m + 1);     vector<int> p(m + 1), way(m + 1);     for (int i = 1; i <= n; ++i) {       p[0] = i;       int j0 = 0;       vector<long long> minv(m + 1, 100LL * INF);       vector<char> used(m + 1, false);       do {         used[j0] = true;         int i0 = p[j0], j1;         long long delta = 100LL * INF;         for (int j = 1; j <= m; ++j)           if (!used[j]) {             long long cur = a[i0][j] - u[i0] - v[j];             if (cur < minv[j]) minv[j] = cur, way[j] = j0;             if (minv[j] < delta) delta = minv[j], j1 = j;           }         for (int j = 0; j <= m; ++j)           if (used[j])             u[p[j]] += delta, v[j] -= delta;           else             minv[j] -= delta;         j0 = j1;       } while (p[j0] != 0);       do {         int j1 = way[j0];         p[j0] = p[j1];         j0 = j1;       } while (j0);     }     vector<int> rv(n);     for (int j = 1; j <= m; ++j) {       rv[p[j] - 1] = j - 1;     }     return rv;   }   struct MinCostFlow {     struct edge {       int b, u, c, f;       size_t back;     };     int n, m;     vector<vector<edge> > g;     MinCostFlow(int n) : n(n), m(0), g(n) {}     void add_edge(int a, int b, int u, int c) {       ++m;       edge r1 = {b, u, c, 0, g[b].size()};       edge r2 = {a, 0, -c, 0, g[a].size()};       g[a].push_back(r1);       g[b].push_back(r2);     }     int flow(int s, int t, int k) {       int flow = 0, cost = 0;       while (flow < k) {         vector<int> id(n, 0);         vector<int> d(n, INF);         vector<int> q(n);         vector<int> p(n);         vector<size_t> p_edge(n);         int qh = 0, qt = 0;         q[qt++] = s;         d[s] = 0;         while (qh != qt) {           int v = q[qh++];           id[v] = 2;           if (qh == n) qh = 0;           for (size_t i = 0; i < g[v].size(); ++i) {             edge &r = g[v][i];             if (r.f < r.u && d[v] + r.c < d[r.b]) {               d[r.b] = d[v] + r.c;               if (id[r.b] == 0) {                 q[qt++] = r.b;                 if (qt == n) qt = 0;               } else if (id[r.b] == 2) {                 if (--qh == -1) qh = n - 1;                 q[qh] = r.b;               }               id[r.b] = 1;               p[r.b] = v;               p_edge[r.b] = i;             }           }         }         if (d[t] == INF) break;         int addflow = k - flow;         for (int v = t; v != s; v = p[v]) {           int pv = p[v];           size_t pr = p_edge[v];           addflow = min(addflow, g[pv][pr].u - g[pv][pr].f);         }         for (int v = t; v != s; v = p[v]) {           int pv = p[v];           size_t pr = p_edge[v], r = g[pv][pr].back;           g[pv][pr].f += addflow;           g[v][r].f -= addflow;           cost += g[pv][pr].c * addflow;         }         flow += addflow;       }       if (flow < k) {         return -1;       }       return cost;     }   };   const int MAXN = 30000;   struct Dinic {     struct edge {       int a, b, cap, flow;     };     int n, s, t, d[MAXN], ptr[MAXN], q[MAXN];     vector<edge> e;     vector<int> g[MAXN];     Dinic(int n) : n(n) {}     void add_edge(int a, int b, int cap) {       edge e1 = {a, b, cap, 0};       edge e2 = {b, a, 0, 0};       g[a].push_back((int)e.size());       e.push_back(e1);       g[b].push_back((int)e.size());       e.push_back(e2);     }     bool bfs() {       int qh = 0, qt = 0;       q[qt++] = s;       memset(d, -1, n * sizeof d[0]);       d[s] = 0;       while (qh < qt && d[t] == -1) {         int v = q[qh++];         for (size_t i = 0; i < g[v].size(); ++i) {           int id = g[v][i], to = e[id].b;           if (d[to] == -1 && e[id].flow < e[id].cap) {             q[qt++] = to;             d[to] = d[v] + 1;           }         }       }       return d[t] != -1;     }     int dfs(int v, int flow) {       if (!flow) return 0;       if (v == t) return flow;       for (; ptr[v] < (int)g[v].size(); ++ptr[v]) {         int id = g[v][ptr[v]], to = e[id].b;         if (d[to] != d[v] + 1) continue;         int pushed = dfs(to, min(flow, e[id].cap - e[id].flow));         if (pushed) {           e[id].flow += pushed;           e[id ^ 1].flow -= pushed;           return pushed;         }       }       return 0;     }     int flow(int S, int T) {       s = S;       t = T;       int flow = 0;       for (;;) {         if (!bfs()) break;         memset(ptr, 0, n * sizeof ptr[0]);         while (int pushed = dfs(s, INF)) flow += pushed;       }       return flow;     }   };   struct MaxFlow {     struct Edge {       int to, c, ne;       Edge(int to, int c, int ne) : to(to), c(c), ne(ne) {}     };     int n;     vector<Edge> ed;     vector<int> fi;     MaxFlow(int n) : n(n), ed(), fi(n, -1) {}     void add_edge(int a, int b, int c) {       ed.push_back(Edge(b, c, fi[a]));       fi[a] = (int)ed.size() - 1;       ed.push_back(Edge(a, c, fi[b]));       fi[b] = (int)ed.size() - 1;     }     vector<char> us;     int dfs(int v, int tar, int cur, int minv = 1) {       if (v == tar) return cur;       if (us[v]) return 0;       us[v] = 1;       for (int i = fi[v]; i != -1; i = ed[i].ne) {         if (ed[i].c < minv) {           continue;         }         int tmp = dfs(ed[i].to, tar, min(cur, ed[i].c), minv);         if (tmp > 0) {           ed[i].c -= tmp;           ed[i ^ 1].c += tmp;           return tmp;         }       }       return 0;     }     int flow(int s, int t) {       int ans = 0, cur, mv = 1;       for (int i = 0; i < 2; ++i) {         do {           us = vector<char>(n);           cur = dfs(s, t, INF, mv);           ans += cur;         } while (cur);       }       return ans;     }   };   struct BoundedMinFlow {     vector<int> a, b;     vector<int> l, r;     int n;     BoundedMinFlow(int n) : n(n) {}     void add_edge(int f, int t, int minc, int maxc) {       a.push_back(f);       b.push_back(t);       l.push_back(minc);       r.push_back(maxc);     }     bool check(int s, int t, int m) {       MaxFlow f(n + 2);       f.add_edge(t, s, m);       int total = 0;       for (int i = 0; i < (int)a.size(); ++i) {         if (l[i] > 0) {           f.add_edge(n, b[i], l[i]);           f.add_edge(a[i], n + 1, l[i]);           total += l[i];         }         if (r[i] > l[i]) {           f.add_edge(a[i], b[i], r[i] - l[i]);         }       }       return (f.flow(n, n + 1) == total);     }     int flow(int s, int t) {       int le = -1, ri = 10000;       if (!check(s, t, ri)) {         return -1;       }       while (le + 1 < ri) {         int mi = (le + ri);         if (check(s, t, mi)) {           ri = mi;         } else {           le = mi;         }       }       return ri;     }   };   int h, w;   string va[16] = { BY ,  BW ,  BR ,  BB ,  RY ,  RW ,  RR ,  WY ,  WW ,  YY };   char vv[16][2];   char st[16][16][4][2];   int cnt[16];   struct pos {     int sx, sy, ex, ey;     int id;     pos() {}     pos(int SX, int SY, int EX, int EY, int ID)         : sx(SX), sy(SY), ex(EX), ey(EY), id(ID) {}     bool operator<(const pos &p) const { return id < p.id; }   };   map<vector<int>, vector<pos> > mp;   char t[16][16];   int lp;   vector<pos> p(28);   vector<int> cur;   bool us[16][16];   int dif[16][16];   char ou[32][32];   int gk[32][32][2];   void prec() {     for (int r = 0; r < h; ++r) {       for (int c = 0; c + 1 < w; ++c) {         int k = -1;         for (int i = 0; i < 10; ++i) {           if ((st[r][c][0][0] == vv[i][0] && st[r][c][0][1] == vv[i][1]) ||               (st[r][c][1][0] == vv[i][0] && st[r][c][1][1] == vv[i][1])) {             k = i;             break;           }         }         gk[r][c][0] = k;       }     }     for (int r = 0; r + 1 < h; ++r) {       for (int c = 0; c < w; ++c) {         int k = -1;         for (int i = 0; i < 10; ++i) {           if ((st[r][c][2][0] == vv[i][0] && st[r][c][2][1] == vv[i][1]) ||               (st[r][c][3][0] == vv[i][0] && st[r][c][3][1] == vv[i][1])) {             k = i;             break;           }         }         gk[r][c][1] = k;       }     }   }   void go(int r, int c) {     if (r >= h) {       if (mp.find(cur) != mp.end()) {         return;       }       mp[cur] = p;       return;     }     if (c >= w) {       go(r + 1, 0);       return;     }     if (us[r][c]) {       go(r, c + 1);       return;     }     if (!us[r][c + 1] && c + 1 < w) {       us[r][c] = us[r][c + 1] = 1;       int k = gk[r][c][0];       cur[k]++;       p[lp].sx = r;       p[lp].sy = c;       p[lp].ex = r;       p[lp].ey = c + 1;       p[lp].id = k;       ++lp;       go(r, c + 2);       cur[k]--;       --lp;       us[r][c] = us[r][c + 1] = 0;     }     if (!us[r + 1][c] && r + 1 < h) {       us[r][c] = us[r + 1][c] = 1;       int k = gk[r][c][1];       cur[k]++;       p[lp].sx = r;       p[lp].sy = c;       p[lp].ex = r + 1;       p[lp].ey = c;       p[lp].id = k;       ++lp;       go(r, c + 1);       cur[k]--;       --lp;       us[r][c] = us[r + 1][c] = 0;     }   }   int main() {     h = 7;     w = 8;     for (int i = 0; i < h; ++i) {       scanf( %s , t[i]);     }     for (int i = 0; i < 10; ++i) {       scanf( %d , &cnt[i]);     }     cur = vector<int>(10, 0);     memset(us, 0, sizeof(us));     for (int i = 0; i < h; ++i) {       for (int j = 0; j + 1 < w; ++j) {         st[i][j][0][0] = t[i][j];         st[i][j][0][1] = t[i][j + 1];         st[i][j][1][0] = t[i][j + 1];         st[i][j][1][1] = t[i][j];       }     }     for (int i = 0; i + 1 < h; ++i) {       for (int j = 0; j < w; ++j) {         st[i][j][2][0] = t[i][j];         st[i][j][2][1] = t[i + 1][j];         st[i][j][3][0] = t[i + 1][j];         st[i][j][3][1] = t[i][j];       }     }     for (int i = 0; i < 10; ++i) {       vv[i][0] = va[i][0];       vv[i][1] = va[i][1];     }     prec();     go(0, 0);     memset(dif, 0, sizeof(dif));     for (int i = 0; i < 10; ++i) {       for (int j = 0; j < 10; ++j) {         dif[i][j] = min((va[i][0] != va[j][0]) + (va[i][1] != va[j][1]),                         (va[i][0] != va[j][1]) + (va[i][1] != va[j][0]));       }     }     int bsol = (1 << 20);     MinCostFlow be(1);     vector<pos> bp;     for (map<vector<int>, vector<pos> >::iterator it = mp.begin(); it != mp.end();          ++it) {       MinCostFlow f(22);       for (int i = 0; i < 10; ++i) {         f.add_edge(20, i, cnt[i], 0);         f.add_edge(10 + i, 21, it->first[i], 0);       }       for (int i = 0; i < 10; ++i) {         for (int j = 0; j < 10; ++j) {           f.add_edge(i, j + 10, INF, dif[i][j]);         }       }       int k = f.flow(20, 21, 28);       if (k < bsol) {         bsol = k;         be = f;         bp = it->second;       }     }     printf( %d n , 56 - bsol);     memset(ou,  . , sizeof(ou));     for (int i = 0; i < (int)bp.size(); ++i) {       int nd = bp[i].id + 10;       for (int j = 0; j < (int)be.g[nd].size(); ++j) {         MinCostFlow::edge &ed = be.g[nd][j];         if (ed.b < 10 && ed.f < 0) {           ++ed.f;           int c1 = (va[ed.b][0] != t[bp[i].sx][bp[i].sy]) +                    (va[ed.b][1] != t[bp[i].ex][bp[i].ey]);           int c2 = (va[ed.b][1] != t[bp[i].sx][bp[i].sy]) +                    (va[ed.b][0] != t[bp[i].ex][bp[i].ey]);           if (c1 <= c2) {             ou[2 * bp[i].sx][2 * bp[i].sy] = va[ed.b][0];             ou[2 * bp[i].ex][2 * bp[i].ey] = va[ed.b][1];           } else {             ou[2 * bp[i].sx][2 * bp[i].sy] = va[ed.b][1];             ou[2 * bp[i].ex][2 * bp[i].ey] = va[ed.b][0];           }           if (bp[i].sx == bp[i].ex) {             ou[2 * bp[i].sx][2 * bp[i].sy + 1] =  - ;           } else {             ou[2 * bp[i].sx + 1][2 * bp[i].sy] =  | ;           }           break;         }       }     }     for (int i = 0; i < 2 * h - 1; ++i) {       ou[i][2 * w - 1] =   0 ;       printf( %s n , ou[i]);     }     return 0;   }   