API tools faq
paste
Advertisement
osipyonok

5632

osipyonok
May 9th, 2017
159
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 14.47 KB | None | 0 0
raw download clone embed print report
  1. #include<bits/stdc++.h>
  2.  
  3. #define INF 1000010000
  4. #define nl '\n'
  5. #define pb push_back
  6. #define ppb pop_back
  7. #define mp make_pair
  8. #define fi first
  9. #define se second
  10. #define pii pair<int,int>
  11. #define pdd pair<double,double>
  12. #define all(c) (c).begin(), (c).end()
  13. #define SORT(c) sort(all(c))
  14. #define sz(c) (c).size()
  15. #define rep(i,n) for( int i = 0; i < n; ++i )
  16. #define repi(i,n) for( int i = 1 ; i <= n; ++i )
  17. #define repn(i,n) for( int i = n - 1 ; i >= 0 ; --i )
  18. #define repf(j,i,n) for( int j = i ; j < n ; ++j )
  19. #define die(s) {std::cout << s << nl;}
  20. #define dier(s) {std::cout << s; return 0;}
  21. #define vi vector<int>
  22. typedef long long ll;
  23. #define MAXN 55
  24. using namespace std;
  25.  
  26. int n , m , k;
  27. vector<pii> life , magic;
  28.  
  29. vi dx = {0 , 1 , 0 , -1};
  30. vi dy = {1 , 0 , -1 , 0};
  31.  
  32. map<char , int> s;
  33.  
  34.  
  35. inline bool ok(pii p){
  36.     int x = p.fi;
  37.     int y = p.se;
  38.     return x >= 0 && x < n && y >= 0 && y < m;
  39. }
  40.  
  41. inline void fill(vector<vi> & v , pii a , pii b , char c){
  42.     for(int i = min(a.fi , b.fi) ; i <= max(a.fi , b.fi) ; ++i){
  43.         for(int j = min(a.se , b.se) ; j <= max(a.se , b.se) ; ++j){
  44.             if(v[i][j] < 3 ){
  45.                 v[i][j] = c;
  46.                 ++s[c];
  47.             }
  48.         }
  49.     }
  50. }
  51.  
  52. inline void fill2(vector<vi> & v , map<pii , pii> & pr , pii a , pii b , char c){
  53.     v[b.fi][b.se] = c;
  54.     while(b != a){
  55.         b = pr[b];
  56.         v[b.fi][b.se] = c;
  57.         ++s[c];
  58.     }
  59.     v[b.fi][b.se] = c;
  60. }
  61.  
  62. void recalc_S(vector<vi> & v){
  63.     s.clear();
  64.     rep(i , n){
  65.         rep(j , m){
  66.             ++s[v[i][j]];
  67.         }
  68.     }
  69. }
  70.  
  71. vector<vi> solve(const vector<pii> & life , const vector<pii> & magic){
  72.     s.clear();
  73.     vector<vi> v(MAXN , vi(MAXN , 0));
  74.    
  75.     queue<pii> q;
  76.    
  77.     rep(i , k){
  78.         v[life[i].fi][life[i].se] = 1;
  79.         v[magic[i].fi][magic[i].se] = 2;
  80.     }
  81.    
  82.     vi index(k);
  83.     rep(i , k){
  84.         queue<pii> q;
  85.         q.push({life[i]});
  86.        
  87.         index[i] = 'a' + i;
  88.        
  89.         v[life[i].fi][life[i].se] = 'a' + i;
  90.        
  91.         vector<vi> used(MAXN , vi(MAXN , 0));
  92.         map<pii , pii> pr;
  93.        
  94.         used[life[i].fi][life[i].se] = 1;
  95.         pr[life[i]] = {-1 , -1};
  96.        
  97.         while(sz(q)){
  98.             pii cur = q.front();
  99.             q.pop();
  100.             if(v[cur.fi][cur.se] > 2 && v[cur.fi][cur.se] != 'a' + i){
  101.                 continue;
  102.             }
  103.    
  104.             bool done = 0;
  105.             rep(j , 4){
  106.                 pii nxt = {cur.fi + dx[j] , cur.se + dy[j]};
  107.                 if(ok(nxt) && v[nxt.fi][nxt.se] < 3 && !used[nxt.fi][nxt.se]){
  108.                     if(v[nxt.fi][nxt.se] == 2){
  109.                         pr[nxt] = cur;
  110.                     //  fill(v , life[i] , nxt , 'a' + i);
  111.                         fill2(v , pr , life[i] , nxt , 'a' + i);
  112.                         done = 1;
  113.                         break;
  114.                     }else if(v[nxt.fi][nxt.se] == 0){
  115.                         pr[nxt] = cur;
  116.                         used[nxt.fi][nxt.se] = 1;
  117.                         q.push(nxt);
  118.                     }
  119.                 }
  120.             }
  121.             if(done){
  122.                 break;
  123.             }
  124.            
  125.         }
  126.        
  127.        
  128.     }
  129.     recalc_S(v);
  130.     return v;
  131. }
  132.  
  133. vector<vi> solve2(const vector<pii> & life , const vector<pii> & magic){
  134.     s.clear();
  135.     vector<vi> v(MAXN , vi(MAXN , 0));
  136.    
  137.     queue<pii> q;
  138.    
  139.     rep(i , k){
  140.         v[life[i].fi][life[i].se] = 1;
  141.         v[magic[i].fi][magic[i].se] = 2;
  142.     }
  143.    
  144.     vi index(k);
  145.     rep(i , k){
  146.         queue<pii> q;
  147.         q.push({life[i]});
  148.        
  149.         index[i] = 'a' + i;
  150.        
  151.         v[life[i].fi][life[i].se] = 'a' + i;
  152.        
  153.         vector<vi> used(MAXN , vi(MAXN , 0));
  154.         map<pii , pii> pr;
  155.        
  156.         used[life[i].fi][life[i].se] = 1;
  157.         pr[life[i]] = {-1 , -1};
  158.        
  159.         while(sz(q)){
  160.             pii cur = q.front();
  161.             q.pop();
  162.             if(v[cur.fi][cur.se] > 2 && v[cur.fi][cur.se] != 'a' + i){
  163.                 continue;
  164.             }
  165.    
  166.             bool done = 0;
  167.             rep(j , 4){
  168.                 pii nxt = {cur.fi + dx[j] , cur.se + dy[j]};
  169.                 if(ok(nxt) && v[nxt.fi][nxt.se] < 3 && !used[nxt.fi][nxt.se]){
  170.                     if(v[nxt.fi][nxt.se] == 2){
  171.                         pr[nxt] = cur;
  172.                         fill(v , life[i] , nxt , 'a' + i);
  173.  
  174.                         done = 1;
  175.                         break;
  176.                     }else if(v[nxt.fi][nxt.se] == 0){
  177.                         pr[nxt] = cur;
  178.                         used[nxt.fi][nxt.se] = 1;
  179.                         q.push(nxt);
  180.                     }
  181.                 }
  182.             }
  183.             if(done){
  184.                 break;
  185.             }
  186.            
  187.         }
  188.        
  189.        
  190.     }
  191.     recalc_S(v);
  192.     return v;
  193. }
  194.  
  195. vector<vi> solve3(vector<pii> life){
  196.     vector<vi> v(MAXN , vi(MAXN , 0));
  197.    
  198.     rep(i , k){
  199.         v[life[i].fi][life[i].se] = 1;
  200.         v[magic[i].fi][magic[i].se] = 2;
  201.     }
  202.    
  203.     int w = 0;
  204.    
  205.     repf(a , 1 , min(7 , n + 1)){
  206.         repf(b , 1 , min(7 , m + 1)){
  207.             if(a == 1 && b == 1)continue;
  208.             rep(i , n - a + 1){
  209.                 rep(j , m - b + 1){
  210.                    
  211.                 int cnt1 = 0 , cnt2 = 0;   
  212.                 pii so = {0 , 0};
  213.                 pii ta = {0 , 0};
  214.                    
  215.                 rep(x , a){
  216.                     rep(y , b){
  217.                         if(v[x + i][y + j] == 1){
  218.                             ++cnt1;
  219.                             so = {x + i , y + j};
  220.                         }else if(v[x + i][y + j] == 2){
  221.                             ++cnt2;
  222.                             ta = {x + i , y + j};
  223.                         }
  224.                     }
  225.                 }
  226.  
  227.                 if(cnt1 == 1 && cnt2 == 1){
  228.                     bool ck = 0;
  229.                    
  230.                     queue<pii> q;
  231.                     vector<vi> used(n , vi(m , 0));
  232.                     used[so.fi][so.se] = 1;
  233.                     q.push(so);
  234.                    
  235.                     while(sz(q)){
  236.                         pii cur = q.front();
  237.                         q.pop();
  238.                        
  239.                         bool done = 0;
  240.                        
  241.                         rep(i , 4){
  242.                             pii nxt = {cur.fi + dx[i] , cur.se + dy[i]};
  243.                             if(ok(nxt)){
  244.                                
  245.                                 if(nxt.fi >= i && nxt.fi < i + a && nxt.se >= j && nxt.se < j + b){
  246.                                    
  247.                                     if(!used[nxt.fi][nxt.se] && v[nxt.fi][nxt.se] < 3){
  248.                                         if(nxt == ta){
  249.                                             done = 1;
  250.                                             ck = 1;
  251.                                             break;
  252.                                         }
  253.                                         used[nxt.fi][nxt.se] = 1;
  254.                                         q.push(nxt);
  255.                                     }
  256.                                    
  257.                                 }
  258.                                
  259.                             }
  260.                         }
  261.                         if(done)break;
  262.                        
  263.                     }
  264.                    
  265.                     if(ck){
  266.                         rep(x , a){
  267.                             rep(y , b){
  268.                                 if(v[x + i][y + j] < 3){
  269.                                     v[x + i][y + j] = w + 'a';         
  270.                                 }
  271.                             }
  272.                         }
  273.                         ++w;
  274.                     }
  275.                     if(w == k){
  276.                         recalc_S(v);
  277.                         return v;
  278.                     }
  279.                    
  280.                 }
  281.  
  282.                 }
  283.             }
  284.            
  285.         }
  286.     }  
  287.    
  288.     return v;
  289. }
  290.  
  291. void finalize(vector<vi> & v){
  292.     bool rec = 0;
  293.     rep(i , n){
  294.         rep(j , m){
  295.             if(v[i][j] == 0){
  296.                 vector<pii> ck;
  297.                 rep(l , 4){
  298.                     pii cur = {i + dx[l] , j + dy[l]};
  299.                     if(ok(cur) && v[cur.fi][cur.se] != 0){
  300.                         ck.pb({s[v[cur.fi][cur.se]] , v[cur.fi][cur.se]});
  301.                     }
  302.                 }
  303.                 SORT(ck);
  304.                 if(!sz(ck)){
  305.                     rec = 1;
  306.                     continue;
  307.                 }
  308.             //  reverse(all(ck));
  309.                 v[i][j] = ck[0].se;
  310.                 ++s[ck[0].se];
  311.             }
  312.         }
  313.     }
  314.     if(rec){
  315.         finalize(v);
  316.     }
  317. }
  318.  
  319.  
  320.  
  321. bool checker(vector<vi> & v , const vector<pii> & life , const vector<pii> & magic){
  322.     vector<vi> t(MAXN , vi(MAXN , 0));
  323.     rep(i , k){
  324.         t[life[i].fi][life[i].se] = 1;
  325.         t[magic[i].fi][magic[i].se] = 2;       
  326.     }
  327.     rep(l , k){
  328.         int cur = 'a' + l;
  329.         int source = 0;
  330.         int target = 0;
  331.         pii so , ta;
  332.         int cnt = 0;
  333.         rep(i , n){
  334.             rep(j , m){
  335.                 if(v[i][j] == cur){
  336.                     ++cnt;
  337.                     if(t[i][j] == 2){
  338.                         if(!target){
  339.                             ++target;
  340.                             ta = {i , j};
  341.                         }else{
  342.                             return 0;
  343.                         }
  344.                     }
  345.                     if(t[i][j] == 1){
  346.                         if(!source){
  347.                             ++source;
  348.                             so = {i , j};
  349.                         }else{
  350.                             return 0;
  351.                         }
  352.                     }
  353.                 }
  354.             }
  355.         }
  356.         if(target != 1 || source != 1)return 0;
  357.        
  358.         vector<vi> used(MAXN , vi(MAXN , 0));
  359.        
  360.         used[so.fi][so.se] = 1;
  361.         queue<pii> q;
  362.         q.push(so);
  363.        
  364.         while(sz(q)){
  365.             pii c = q.front();
  366.             q.pop();
  367.             if(v[c.fi][c.se] == cur){
  368.                 --cnt;
  369.             }
  370.             rep(i , 4){
  371.                 pii nxt = {c.fi + dx[i] , c.se + dy[i]};
  372.                 if(ok(nxt) && !used[nxt.fi][nxt.se] && v[nxt.fi][nxt.se] == cur){
  373.                     used[nxt.fi][nxt.se] = 1;
  374.                     q.push(nxt);
  375.                 }
  376.             }
  377.         }
  378.         if(cnt)return 0;
  379.     }
  380.     return 1;
  381. }
  382.  
  383. inline pii get_next(vector<vi> & v , pii a){
  384.     rep(i , 4){
  385.         pii b = {a.fi + dx[i] , a.se + dy[i]};
  386.         if(ok(b) && v[b.fi][b.se] == v[a.fi][a.se]){
  387.             return b;
  388.         }
  389.     }
  390.     return {a.fi + dx[0] , a.se + dy[0]};
  391. }
  392.  
  393. inline pii get_first(vector<vi> & v , int cur){
  394.     rep(i , n){
  395.         rep(j , m){
  396.             if(v[i][j] == cur){
  397.                 return {i , j};
  398.             }
  399.         }
  400.     }
  401.     return {0 , 0};
  402. }
  403.  
  404. int P(vector<vi> & v , int cur){
  405.     int p = 0;
  406.     rep(j , m){
  407.         rep(i , n){
  408.             pii next = {i + 1 , j};
  409.             pii prev = {i - 1 , j};
  410.             if(ok(next) && v[i][j] == cur && v[i + 1][j] != cur){
  411.                 ++p;
  412.             }
  413.             if(ok(prev) && v[i][j] == cur && v[i - 1][j] != cur){
  414.                 ++p;
  415.             }
  416.             if(!ok(next) && v[i][j] == cur){
  417.                 ++p;
  418.             }
  419.             if(!ok(prev) && v[i][j] == cur){
  420.                 ++p;
  421.             }
  422.         }
  423.     }
  424.        
  425.    
  426.     rep(i , n){
  427.         rep(j , m){
  428.             pii next = {i , j + 1};
  429.             pii prev = {i , j - 1};
  430.             if(ok(next) && v[i][j] == cur && v[i][j + 1] != cur){
  431.                 ++p;
  432.             }
  433.             if(ok(prev) && v[i][j] == cur && v[i][j - 1] != cur){
  434.                 ++p;
  435.             }
  436.             if(!ok(next) && v[i][j] == cur){
  437.                 ++p;
  438.             }
  439.             if(!ok(prev) && v[i][j] == cur){
  440.                 ++p;
  441.             }
  442.         }
  443.     }
  444.     return p;
  445. }
  446.  
  447.  
  448. int drop_p(vector<vi> & v , int x , int y , int p){
  449.     int bias = 0;
  450.     rep(i , 4){
  451.         int xx = x + dx[i];
  452.         int yy = y + dy[i];
  453.         if(ok({xx , yy})){
  454.             if(v[xx][yy] == v[x][y]){
  455.                 ++bias;
  456.             }else{
  457.                 --bias;
  458.             }
  459.         }else{
  460.             --bias;
  461.         }
  462.     }
  463.     return p + bias;
  464. }
  465.  
  466. int add_p(vector<vi> & v , int x , int y , int p){
  467.     int bias = 0;
  468.     rep(i , 4){
  469.         int xx = x + dx[i];
  470.         int yy = y + dy[i];
  471.         if(ok({xx , yy})){
  472.             if(v[xx][yy] == v[x][y]){
  473.                 ++bias;
  474.             }else{
  475.                 --bias;
  476.             }
  477.         }else{
  478.             --bias;
  479.         }
  480.     }
  481.     return p - bias;
  482. }
  483.  
  484. void swapper(vector<vi> & v , const vector<pii> & life , const vector<pii> & magic){
  485.     vector<vi> need(MAXN , vi(MAXN , 0));
  486.    
  487.     rep(i , k){
  488.         need[life[i].fi][life[i].se] = 1;
  489.         need[magic[i].fi][magic[i].se] = 2;    
  490.     }
  491.    
  492.     rep(i , k){
  493.         queue<pii> q;
  494.         vector<vi> used(MAXN , vi(MAXN , 0));
  495.         int pr[MAXN][MAXN][2];
  496.         used[life[i].fi][life[i].se] = 1;
  497.         q.push(life[i]);
  498.         rep(x , n)
  499.             rep(y , m)
  500.                 pr[x][y][0] = pr[x][y][1] = 0;
  501.         pii ta = {0 , 0};
  502.        
  503.         while(sz(q)){
  504.             pii cur = q.front();
  505.             q.pop();
  506.             bool done = 0;
  507.             rep(j , 4){
  508.                 pii nxt = {cur.fi + dx[j] , cur.se + dy[j]};
  509.                 if(ok(nxt) && !used[nxt.fi][nxt.se] && v[nxt.fi][nxt.se] == v[life[i].fi][life[i].se]){
  510.                     pr[nxt.fi][nxt.se][0] = cur.fi;
  511.                     pr[nxt.fi][nxt.se][1] = cur.se;
  512.                     used[nxt.fi][nxt.se] = 1;
  513.                     if(need[nxt.fi][nxt.se] == 2){
  514.                         ta = nxt;
  515.                         done = 1;
  516.                         break;
  517.                     }
  518.                     q.push(nxt);
  519.                 }
  520.             }
  521.             if(done)break;
  522.         }
  523.        
  524.         need[ta.fi][ta.se] = 1;
  525.         while(ta != life[i]){
  526.             int x = pr[ta.fi][ta.se][0];
  527.             int y = pr[ta.fi][ta.se][1];
  528.             ta = {x , y};
  529.             need[ta.fi][ta.se] = 1;
  530.         }
  531.         need[ta.fi][ta.se] = 1;
  532.     }
  533.     /*
  534.     rep(i , n){
  535.         rep(j , m){
  536.             cout << need[i][j];
  537.         }
  538.         cout << nl;
  539.     }*/
  540.    
  541.     map<int , int> p;
  542.     rep(i , k){
  543.         p['a' + i] = P(v , 'a' + i);
  544.     }
  545.    
  546.     rep(i , n){
  547.         rep(j , m){
  548.             if(!need[i][j]){
  549.                 int best = v[i][j];
  550.                 int best_p = p[best];
  551.                 int best_s = s[best];
  552.                
  553.                 int r_p = drop_p(v , i , j , best_p);
  554.                 int r_s = best_s - 1;
  555.    
  556.  
  557.                
  558.                 rep(l , 4){
  559.                     int x = i + dx[l];
  560.                     int y = j + dy[l];
  561.                     if(ok({x , y})){
  562.                         int cur = v[x][y];
  563.                         if(cur != best){
  564.                             int cur_p = p[cur];//P(v , cur);
  565.                             int cur_s = s[cur];
  566.                         //  v[i][j] = cur;
  567.                             int ck_p = add_p(v , x , y , cur_p);
  568.                            
  569.                             int ck_s = cur_s + 1;
  570.                         //  v[i][j] = best;
  571.                         //  cout << ck_p << " " << add_p(v , x , y , cur_p) << nl;
  572.                            
  573.                             double d1 = ((double)best_s / (double)(best_p * best_p)) +
  574.                                             ((double)cur_s / (double)(cur_p * cur_p));
  575.                             double d2 = ((double)r_s / (double)(r_p * r_p)) +
  576.                                             ((double)ck_s / (double)(ck_p * ck_p));
  577.                            
  578.                             if(d2 > d1){
  579.                                 p[cur] = ck_p;
  580.                                 p[best] = r_p;
  581.                                 s[cur] = ck_s;
  582.                                 s[best] = ck_s;
  583.                                
  584.                                 best = cur;
  585.                                 best_p = ck_p;
  586.                                 best_s = ck_s;
  587.                            
  588.                                
  589.                                 r_p = cur_p;
  590.                                 r_s = cur_s;
  591.                                 v[i][j] = best;
  592.                                
  593.                             }              
  594.                            
  595.                         }
  596.                     }
  597.                 }
  598.                
  599.         //      cout << (char)best << " " << best_p << " " << best_s << nl;
  600.             }
  601.         }
  602.     }
  603. }
  604.  
  605.  
  606. double sum(vector<vi> & v , const vector<pii> & life , const vector<pii> & magic , bool flag = 0){
  607.     recalc_S(v);
  608.     if(flag){
  609.         rep(i , n){
  610.             rep(j , m){
  611.                 cout << (char)v[i][j] ;
  612.             }
  613.             cout << nl;
  614.         }
  615.        
  616.     }
  617.     double res = 0;
  618.     rep(l , k){
  619.         int cur = 'a' + l;
  620.         int p = P(v , cur);
  621.         int S = s[cur];
  622.        
  623.         if(flag)cout << (char)cur << " " << S << nl;
  624.         res += (double)S / (double)(p * p);
  625.     }
  626.     return res;
  627. }
  628.  
  629.  
  630. int main() {
  631.     ios_base::sync_with_stdio(false);
  632.     cin.tie(NULL);
  633. //  cout.precision(10);
  634. //  cout.setf(ios::fixed);
  635.  
  636.     cin >> n >> m >> k;
  637.     life.resize(k);
  638.     magic.resize(k);
  639.    
  640.     rep(i , k){
  641.         cin >> life[i].fi >> life[i].se;
  642.     }
  643.    
  644.     rep(i , k){
  645.         cin >> magic[i].fi >> magic[i].se;
  646.     }
  647. /* 
  648.     struct{
  649.         bool operator()(pii & a , pii & b){  
  650.             int d1 = INF , d2 = INF;
  651.             rep(i , k){
  652.                 d1 =  min(d1 , abs(a.fi - magic[i].fi) + abs(a.se - magic[i].se));
  653.                 d2 =  min(d2 , abs(b.fi - magic[i].fi) + abs(b.se - magic[i].se));
  654.             }
  655.             return d1 < d2;
  656.         }  
  657.     }comp;
  658.  
  659.     sort(all(life) , comp);*/
  660.     auto v2 = solve3(life);
  661.     finalize(v2);
  662.    
  663.     auto v1 = solve(life , magic);
  664.    
  665.     finalize(v1);
  666.  
  667.     ll start = clock();
  668.    
  669.     vector<vi> best = v1;
  670.     double best_res = -INF;
  671.     if(checker(v1 , life , magic)){
  672.         best_res = sum(v1 , life , magic);
  673.     }
  674.    
  675.     if(checker(v2 , life , magic)){
  676.         double d = sum(v2 , life , magic);
  677.         if(d > best_res){
  678.             best_res = d;
  679.             best = v2;
  680.         }
  681.     }
  682.    
  683.    
  684.     rep(kk , 5){
  685.         random_shuffle(all(life));
  686.         random_shuffle(all(magic));
  687.         v1 = solve(life , magic);
  688.         finalize(v1);
  689.  
  690.         if(checker(v1 , life , magic)){
  691.             double d = sum(v1 , life , magic);
  692.             if(d > best_res){
  693.                 best_res = d;
  694.                 best = v1;
  695.             }
  696.         }
  697.        
  698.        
  699.         v1 = solve2(life , magic);
  700.    
  701.         finalize(v1);
  702.         //if(k < 5 && kk < 5)
  703.         //  swapper(v1 , life , magic);
  704.         if(checker(v1 , life , magic)){
  705.             double d = sum(v1 , life , magic);
  706.             if(d > best_res){
  707.                 best_res = d;
  708.                 best = v1;
  709.             }
  710.         }
  711.     }
  712.  
  713.     v1 = best;
  714. /*  if(checker(v1 , life , magic) == 0){
  715.         do{
  716.             random_shuffle(all(life));
  717.             random_shuffle(all(magic));
  718.             v1 = solve(life , magic);
  719.            
  720.             finalize(v1);
  721.         }while(checker(v1 , life , magic) == 0);
  722.         best = v1;
  723.     }*/
  724. //  cout << start << " " << clock() << " " << clock() - start << nl;
  725.     while(clock() - start < 1500000){
  726.     //  cout << "hi\n";
  727.         random_shuffle(all(life));
  728.         random_shuffle(all(magic));
  729.         v1 = solve(life , magic);
  730.         finalize(v1);
  731.         if(checker(v1 , life , magic)){
  732.             double d = sum(v1 , life , magic);
  733.             if(d > best_res){
  734.                 best_res = d;
  735.                 best = v1;
  736.             }
  737.         }
  738.        
  739.        
  740.         v1 = solve2(life , magic);
  741.         finalize(v1);
  742.         if(checker(v1 , life , magic)){
  743.             double d = sum(v1 , life , magic);
  744.             if(d > best_res){
  745.                 best_res = d;
  746.                 best = v1;
  747.             }
  748.         }  
  749.     }
  750.    
  751.  
  752.     v2 = best;
  753.     swapper(v2 , life , magic);
  754.     if(checker(v2 , life , magic)){
  755.         if(sum(v2, life , magic) > best_res)best = v2;
  756. //      swapper(v2 , life , magic);
  757.     }
  758.    
  759.  
  760.  
  761.     rep(i , n){
  762.         rep(j , m){
  763.             cout << (char)best[i][j];
  764.         }
  765.         cout << nl;
  766.     }
  767.    
  768. //  sum(best , life , magic , 1);
  769.    
  770.    
  771.     return 0;
  772. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!