fork download
copy 
  1.  
  2. #include <bits/stdc++.h>
  3.  
  4. //_ ******************* Policy Based Data Structure ****************************
  5.  
  6. #include <ext/pb_ds/assoc_container.hpp>
  7. #include <ext/pb_ds/tree_policy.hpp>
  8.  
  9. using namespace std;
  10. using namespace __gnu_pbds;
  11.  
  12.  
  13. template <class T>
  14. using ordered_set = tree<
  15. 	T,
  16. 	null_type,
  17. 	less<T>,
  18. 	rb_tree_tag,
  19. 	tree_order_statistics_node_update
  20. >;
  21.  
  22. //_ ****************************************************************************
  23.  
  24.  
  25. #define int              long long int
  26. #define double           long double
  27. #define print(a)         for(auto x : a) cout << x << " "; cout << endl
  28. inline int power(int a, int b) {
  29.     int x = 1;
  30.     while (b) {
  31.         if (b & 1) x *= a;
  32.         a *= a;
  33.         b >>= 1;
  34.     }
  35.     return x;
  36. }
  37.  
  38.  
  39. const int M = 1000000007;
  40. const int N = 3e5+9;
  41. const int INF = 2e9+1;
  42. const int LINF = 2000000000000000001;
  43.  
  44. //_ ***************************** START Below *******************************
  45.  
  46.  
  47.  
  48.  
  49. typedef pair<int, int> pii;
  50.  
  51.  
  52.  
  53.  
  54.  
  55. vector<int> a;
  56.  
  57. vector<double> consistency1(int n, int k) {
  58.     vector<double> ans;
  59.  
  60. 	set<pii> rightMin; // max heap
  61. 	set<pii, greater<pii>> leftMax; //* min heap
  62.  
  63.  
  64.     int s = 0, e = 0;    
  65.     while(e<n){
  66.         leftMax.insert({a[e], e});
  67.  
  68.         //* rebalance now
  69.         if(leftMax.size() > k/2){
  70.             auto x = *leftMax.begin();
  71.             leftMax.erase(x);
  72.             rightMin.insert(x);
  73.         }        if(e-s+1 < k){
  74.             e++;
  75.         }
  76.         else{
  77.             int x = (*leftMax.begin()).first;
  78.             int y = (*rightMin.begin()).first;
  79.             double median = (x + 0.0 +y)/2.0;
  80.             if(k & 1){
  81.                 median = y;
  82.             }
  83.             ans.push_back(median);            
  84.             leftMax.erase({a[s], s});
  85.             rightMin.erase({a[s], s});
  86.  
  87.             //* rebalance now
  88.             if(leftMax.size() < k/2){
  89.                 auto y = *rightMin.begin();
  90.                 rightMin.erase(y);
  91.                 leftMax.insert(y);
  92.             }
  93.             s++;
  94.             e++;
  95.         }
  96.     }
  97.     return ans;
  98. }
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108. void rebalance(set<pii, greater<pii>>& leftMax, set<pii>& rightMin){
  109.  
  110.     if(!leftMax.empty() && !rightMin.empty() && (*rightMin.begin()).first < (*leftMax.begin()).first ){
  111.         auto leftTop = *leftMax.begin();
  112.         auto rightTop = *rightMin.begin();
  113.  
  114.         leftMax.erase(leftTop);
  115.         rightMin.erase(rightTop);
  116.  
  117.         leftMax.insert(rightTop);
  118.         rightMin.insert(leftTop);
  119.     }
  120.  
  121.     if(leftMax.size() > rightMin.size()){
  122.         auto leftTop = *leftMax.begin();
  123.         leftMax.erase(leftTop);
  124.         rightMin.insert(leftTop);
  125.     }
  126.     else if(rightMin.size() > leftMax.size()+1 ){
  127.         auto rightTop = *rightMin.begin();
  128.         rightMin.erase(rightTop);
  129.         leftMax.insert(rightTop);
  130.     }
  131. }
  132.  
  133.  
  134. vector<int> consistency2(int n, int k) {
  135.     vector<int> ans;
  136.  
  137. 	set<pii, greater<pii> > leftMax;
  138. 	set<pii> rightMin;
  139.  
  140.     int s = 0, e = 0;
  141.     while(e < n){
  142.         leftMax.insert({a[e], e});
  143.         rebalance(leftMax, rightMin);
  144.  
  145.  
  146.         if(e - s + 1 < k){
  147.             e++;
  148.         }
  149.         else{
  150.             auto rightTop = *rightMin.begin();
  151.             double median = rightTop.first;
  152.  
  153.             if( !(k & 1) ) {
  154.                 auto leftTop = *leftMax.begin();
  155.                 median = (leftTop.first + 0.0 + rightTop.first) / 2.0;
  156.             }
  157.  
  158.             ans.push_back(median);
  159.  
  160.             if(leftMax.count({a[s], s})){
  161.                 leftMax.erase({a[s],s});
  162.             }
  163.             else {
  164.                 rightMin.erase({a[s],s});
  165.             }
  166.             rebalance(leftMax, rightMin);
  167.  
  168.             s++;
  169.             e++;
  170.         }
  171.     }
  172.  
  173.     return ans;
  174. }
  175.  
  176.  
  177.  
  178.  
  179.  
  180.  
  181. //? Using Ordered set from Policy based ds 
  182.  
  183. vector<double> consistency3(int n, int k) {
  184.     vector<double> ans;
  185.  
  186.     ordered_set<pair<int, int>> window;
  187.  
  188.     int s = 0, e = 0;
  189.     while(e<n) {
  190.         window.insert({a[e], e});
  191.  
  192.         if (e-s+1 < k) {
  193.         	e++;
  194.         }
  195.         else{
  196.         	if (k & 1) {
  197.                 auto it = window.find_by_order(k / 2);
  198.                 ans.push_back((double)it->first);
  199.             } else {
  200.                 auto it1 = window.find_by_order(k / 2 - 1);
  201.                 auto it2 = window.find_by_order(k / 2);
  202.                 double median = (it1->first + 0.0 + it2->first) / 2.0;
  203.                 ans.push_back(median);
  204.             }
  205.             window.erase({a[s], s});
  206.         	s++;
  207.         	e++;
  208.         }
  209.     }
  210.  
  211.     return ans;
  212. }
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231. vector<double> practice(int n, int k) {
  232.  
  233. 	return {};
  234.  
  235. }
  236.  
  237.  
  238.  
  239.  
  240. void solve() {
  241.  
  242.     int n, k;
  243.     cin>>n >> k;
  244.  
  245. 	a.resize(n);
  246.     for(int i=0; i<n; i++) cin >> a[i];
  247.  
  248.     auto ans1 = consistency1(n, k);
  249.     for(auto& it : ans1 ) {
  250.     	cout << it << " ";
  251.     }
  252.     cout << "   :   ";
  253.  
  254.     auto ans2 = consistency2(n, k);
  255.     for(auto& it : ans2 ) {
  256.     	cout << it << " ";
  257.     }
  258.     cout << "   :   ";
  259.  
  260.     auto ans3 = consistency3(n, k);
  261.     for(auto& it : ans3 ) {
  262.     	cout << it << " ";
  263.     }
  264.     cout << endl;
  265.  
  266.  
  267.  
  268.     // auto p = practice(n, k);
  269.     // cout << " -> ";
  270.     // for(auto& it : ans1 ) {
  271.     // 	cout << it << " ";
  272.     // }
  273.     // cout << endl;
  274.  
  275.  
  276.  
  277. }
  278.  
  279.  
  280.  
  281.  
  282.  
  283. int32_t main() {
  284.     ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
  285.  
  286.     int t = 1;
  287.     cin >> t;
  288.     while (t--) {
  289.         solve();
  290.     }
  291.  
  292.     return 0;
  293. }
Success #stdin #stdout 0.01s 5324KB
comments (?)
stdin
copy 
3
8 3
1 3 -1 -3 5 3 6 7
9 3
1 2 3 4 2 3 1 4 2
6 3
1 1 3 2 0 0
stdout
copy 
1 -1 -1 3 5 6    :   1 -1 -1 3 5 6    :   1 -1 -1 3 5 6 
2 3 3 3 2 3 2    :   2 3 3 3 2 3 2    :   2 3 3 3 2 3 2 
1 2 2 0    :   1 2 2 0    :   1 2 2 0
https://ideone.com/TS1JBN
language:
C++14 (gcc 8.3)
created:
22 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!