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.  
  58. //* Using Set 
  59.  
  60. vector<double> consistency1(int n, int k) {
  61.     vector<double> ans;
  62.  
  63. 	set<pii> rightMin; // max heap
  64. 	set<pii, greater<pii>> leftMax; //* min heap
  65.  
  66.  
  67.     int s = 0, e = 0;    
  68.     while(e<n){
  69.         leftMax.insert({a[e], e});
  70.  
  71.         //* rebalance now
  72.         if(leftMax.size() > k/2){
  73.             auto x = *leftMax.begin();
  74.             leftMax.erase(x);
  75.             rightMin.insert(x);
  76.         }        if(e-s+1 < k){
  77.             e++;
  78.         }
  79.         else{
  80.             int x = (*leftMax.begin()).first;
  81.             int y = (*rightMin.begin()).first;
  82.             double median = (x + 0.0 +y)/2.0;
  83.             if(k & 1){
  84.                 median = y;
  85.             }
  86.             ans.push_back(median);            
  87.             leftMax.erase({a[s], s});
  88.             rightMin.erase({a[s], s});
  89.  
  90.             //* rebalance now
  91.             if(leftMax.size() < k/2){
  92.                 auto y = *rightMin.begin();
  93.                 rightMin.erase(y);
  94.                 leftMax.insert(y);
  95.             }
  96.             s++;
  97.             e++;
  98.         }
  99.     }
  100.     return ans;
  101. }
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109. //* Using Set 
  110.  
  111. void rebalance(set<pii, greater<pii>>& leftMax, set<pii>& rightMin){
  112.  
  113.     if(!leftMax.empty() && !rightMin.empty() && (*rightMin.begin()).first < (*leftMax.begin()).first ){
  114.         auto leftTop = *leftMax.begin();
  115.         auto rightTop = *rightMin.begin();
  116.  
  117.         leftMax.erase(leftTop);
  118.         rightMin.erase(rightTop);
  119.  
  120.         leftMax.insert(rightTop);
  121.         rightMin.insert(leftTop);
  122.     }
  123.  
  124.     if(leftMax.size() > rightMin.size()){
  125.         auto leftTop = *leftMax.begin();
  126.         leftMax.erase(leftTop);
  127.         rightMin.insert(leftTop);
  128.     }
  129.     else if(rightMin.size() > leftMax.size()+1 ){
  130.         auto rightTop = *rightMin.begin();
  131.         rightMin.erase(rightTop);
  132.         leftMax.insert(rightTop);
  133.     }
  134. }
  135.  
  136.  
  137. vector<int> consistency2(int n, int k) {
  138.     vector<int> ans;
  139.  
  140. 	set<pii, greater<pii> > leftMax;
  141. 	set<pii> rightMin;
  142.  
  143.     int s = 0, e = 0;
  144.     while(e < n){
  145.         leftMax.insert({a[e], e});
  146.         rebalance(leftMax, rightMin);
  147.  
  148.  
  149.         if(e - s + 1 < k){
  150.             e++;
  151.         }
  152.         else{
  153.             auto rightTop = *rightMin.begin();
  154.             double median = rightTop.first;
  155.  
  156.             if( !(k & 1) ) {
  157.                 auto leftTop = *leftMax.begin();
  158.                 median = (leftTop.first + 0.0 + rightTop.first) / 2.0;
  159.             }
  160.  
  161.             ans.push_back(median);
  162.  
  163.             if(leftMax.count({a[s], s})){
  164.                 leftMax.erase({a[s],s});
  165.             }
  166.             else {
  167.                 rightMin.erase({a[s],s});
  168.             }
  169.             rebalance(leftMax, rightMin);
  170.  
  171.             s++;
  172.             e++;
  173.         }
  174.     }
  175.  
  176.     return ans;
  177. }
  178.  
  179.  
  180.  
  181.  
  182.  
  183.  
  184. //? Using Ordered set from Policy based ds 
  185.  
  186. vector<double> consistency3(int n, int k) {
  187.     vector<double> ans;
  188.  
  189.     ordered_set<pair<int, int>> window;
  190.  
  191.     int s = 0, e = 0;
  192.     while(e<n) {
  193.         window.insert({a[e], e});
  194.  
  195.         if (e-s+1 < k) {
  196.         	e++;
  197.         }
  198.         else{
  199.         	if (k & 1) {
  200.                 auto it = window.find_by_order(k / 2);
  201.                 ans.push_back((double)it->first);
  202.             } else {
  203.                 auto it1 = window.find_by_order(k / 2 - 1);
  204.                 auto it2 = window.find_by_order(k / 2);
  205.                 double median = (it1->first + 0.0 + it2->first) / 2.0;
  206.                 ans.push_back(median);
  207.             }
  208.             window.erase({a[s], s});
  209.         	s++;
  210.         	e++;
  211.         }
  212.     }
  213.  
  214.     return ans;
  215. }
  216.  
  217.  
  218.  
  219.  
  220.  
  221. // Lazy Deletion on Priority queue
  222.  
  223. void rebalance2(priority_queue<pii>& leftMax, priority_queue<pii, vector<pii>, greater<pii>>& rightMin, vector<bool>& deleted, vector<bool>& in_left, int& validLeft, int& validRight) {
  224.  
  225.     while(!leftMax.empty() && deleted[leftMax.top().second]) leftMax.pop();
  226.     while(!rightMin.empty() && deleted[rightMin.top().second]) rightMin.pop();
  227.  
  228.     if(!leftMax.empty() && !rightMin.empty() && rightMin.top().first < leftMax.top().first) {
  229.         auto left = leftMax.top();
  230.         auto right = rightMin.top();
  231.  
  232.         leftMax.pop();
  233.         rightMin.pop();
  234.  
  235.         // Update tracking states since they swapped heaps
  236.         in_left[left.second] = false;
  237.         in_left[right.second] = true;
  238.  
  239.         leftMax.push(right);
  240.         rightMin.push(left);
  241.     }
  242.  
  243.     while(!leftMax.empty() && deleted[leftMax.top().second]) leftMax.pop();
  244.     while(!rightMin.empty() && deleted[rightMin.top().second]) rightMin.pop();
  245.  
  246.     if(validLeft > validRight) {
  247.         auto left = leftMax.top();
  248.         leftMax.pop();
  249.  
  250.         in_left[left.second] = false;
  251.         validLeft--;
  252.         validRight++;
  253.  
  254.         rightMin.push(left);
  255.     }
  256.     else if(validRight > validLeft + 1) {
  257.         auto right = rightMin.top();
  258.         rightMin.pop();
  259.  
  260.         in_left[right.second] = true;
  261.         validRight--;
  262.         validLeft++;
  263.  
  264.         leftMax.push(right);
  265.     }
  266. }
  267.  
  268.  
  269. vector<double> consistency4(int n, int k) {
  270.     vector<double> ans; 
  271.  
  272.     priority_queue<pii> leftMax;
  273.     priority_queue<pii, vector<pii>, greater<pii>> rightMin;
  274.  
  275.     vector<bool> deleted(n, false);
  276.     vector<bool> in_left(n, false);
  277.     int validLeft = 0, validRight = 0;
  278.  
  279.     int s = 0, e = 0;
  280.  
  281.     while(e < n) {
  282.         leftMax.push({a[e], e});
  283.         in_left[e] = true;
  284.         validLeft++;
  285.  
  286.         rebalance2(leftMax, rightMin, deleted, in_left, validLeft, validRight);
  287.  
  288.         if(e-s+1 < k) {
  289.             e++;
  290.         }
  291.         else {
  292.             while(!leftMax.empty() && deleted[leftMax.top().second]) leftMax.pop();
  293.             while(!rightMin.empty() && deleted[rightMin.top().second]) rightMin.pop();
  294.  
  295.             double x = leftMax.empty() ? 0 : leftMax.top().first;
  296.             double y = rightMin.empty() ? 0 : rightMin.top().first;
  297.  
  298.             double median = y; 
  299.  
  300.             if( !(k & 1) ) {
  301.                 median = (x + y) / 2.0;
  302.             }
  303.  
  304.             ans.push_back(median);
  305.  
  306.             deleted[s] = true;
  307.             if (in_left[s]) validLeft--;
  308.             else validRight--;
  309.  
  310.             rebalance2(leftMax, rightMin, deleted, in_left, validLeft, validRight);
  311.  
  312.             s++;
  313.             e++;
  314.         }
  315.     }
  316.  
  317.     return ans;
  318. }
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336. vector<double> practice(int n, int k) {
  337.  
  338. 	return {};
  339.  
  340. }
  341.  
  342.  
  343.  
  344.  
  345. void solve() {
  346.  
  347.     int n, k;
  348.     cin>>n >> k;
  349.  
  350. 	a.resize(n);
  351.     for(int i=0; i<n; i++) cin >> a[i];
  352.  
  353.     auto ans1 = consistency1(n, k);
  354.     for(auto& t : ans1 )	cout << t << " ";	cout << "   :   ";
  355.  
  356.     auto ans2 = consistency2(n, k);
  357.     for(auto& t : ans2 )	cout << t << " ";	cout << "   :   ";
  358.  
  359.     auto ans3 = consistency3(n, k);
  360.     for(auto& t : ans3 )	cout << t << " ";	cout << "   :   ";
  361.  
  362.     auto ans4 = consistency4(n, k);
  363.     for(auto& t : ans4 )	cout << t << " ";	cout << endl;
  364.  
  365.  
  366.     // auto p = practice(n, k);
  367.     // cout << " -> ";
  368.     // for(auto& it : ans1 ) {
  369.     // 	cout << it << " ";
  370.     // }
  371.     // cout << endl;
  372.  
  373.  
  374.  
  375. }
  376.  
  377.  
  378.  
  379.  
  380.  
  381. int32_t main() {
  382.     ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
  383.  
  384.     int t = 1;
  385.     cin >> t;
  386.     while (t--) {
  387.         solve();
  388.     }
  389.  
  390.     return 0;
  391. }
Success #stdin #stdout 0.01s 5320KB
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    :   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    :   2 3 3 3 2 3 2 
1 2 2 0    :   1 2 2 0    :   1 2 2 0    :   1 2 2 0
https://ideone.com/suQLTT
language:
C++14 (gcc 8.3)
created:
2 days 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!