fork download
copy 
  1. #pragma GCC optimize ("Ofast")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. void*wmem;
  5. char memarr[96000000];
  6. template<class T> inline void walloc1d(T **arr, int x, void **mem = &wmem){
  7.   static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
  8.   (*mem) = (void*)( ((char*)(*mem)) + skip[((unsigned long long)(*mem)) & 15] );
  9.   (*arr)=(T*)(*mem);
  10.   (*mem)=((*arr)+x);
  11. }
  12. template<class T> inline void walloc1d(T **arr, int x1, int x2, void **mem = &wmem){
  13.   walloc1d(arr, x2-x1, mem);
  14.   (*arr) -= x1;
  15. }
  16. struct Rand{
  17.   unsigned x;
  18.   unsigned y;
  19.   unsigned z;
  20.   unsigned w;
  21.   Rand(void){
  22.     x=123456789;
  23.     y=362436069;
  24.     z=521288629;
  25.     w=(unsigned)time(NULL);
  26.   }
  27.   Rand(unsigned seed){
  28.     x=123456789;
  29.     y=362436069;
  30.     z=521288629;
  31.     w=seed;
  32.   }
  33.   inline unsigned get(void){
  34.     unsigned t;
  35.     t = (x^(x<<11));
  36.     x=y;
  37.     y=z;
  38.     z=w;
  39.     w = (w^(w>>19))^(t^(t>>8));
  40.     return w;
  41.   }
  42.   inline double getUni(void){
  43.     return get()/4294967296.0;
  44.   }
  45.   inline int get(int a){
  46.     return (int)(a*getUni());
  47.   }
  48.   inline int get(int a, int b){
  49.     return a+(int)((b-a+1)*getUni());
  50.   }
  51.   inline long long get(long long a){
  52.     return(long long)(a*getUni());
  53.   }
  54.   inline long long get(long long a, long long b){
  55.     return a+(long long)((b-a+1)*getUni());
  56.   }
  57.   inline double get(double a, double b){
  58.     return a+(b-a)*getUni();
  59.   }
  60.   inline int getExp(int a){
  61.     return(int)(exp(getUni()*log(a+1.0))-1.0);
  62.   }
  63.   inline int getExp(int a, int b){
  64.     return a+(int)(exp(getUni()*log((b-a+1)+1.0))-1.0);
  65.   }
  66. }
  67. ;
  68. template<class T> int LIS_length(int n, T a[], void *mem = wmem){
  69.   int i;
  70.   int k;
  71.   int res;
  72.   T*arr;
  73.   if(n==0){
  74.     return 0;
  75.   }
  76.   walloc1d(&arr, n, &mem);
  77.   arr[0] = a[0];
  78.   res = 1;
  79.   int cTE1_r3A = n;
  80.   for(i=(1);i<(cTE1_r3A);i++){
  81.     k = lower_bound(arr, arr+res, a[i]) - arr;
  82.     arr[k] = a[i];
  83.     if(res==k){
  84.       res++;
  85.     }
  86.   }
  87.   return res;
  88. }
  89. unsigned long long HashMap_ullP_L[4];
  90. template<class KEY, class VAL> struct HashMap{
  91.   char*used;
  92.   KEY*key;
  93.   VAL*val;
  94.   int mem;
  95.   int n;
  96.   int mask;
  97.   HashMap(){
  98.     mem = 0;
  99.   }
  100.   ~HashMap(){
  101.     free();
  102.   }
  103.   void expand(int nn){
  104.     if(mem >= nn){
  105.       return;
  106.     }
  107.     if(mem){
  108.       free();
  109.     }
  110.     mem = nn;
  111.     used = new char[nn];
  112.     key = new KEY[nn];
  113.     val = new VAL[nn];
  114.   }
  115.   void free(){
  116.     if(mem){
  117.       mem = 0;
  118.       delete[] used;
  119.       delete[] key;
  120.       delete[] val;
  121.     }
  122.   }
  123.   void init(int nn){
  124.     int i;
  125.     n = 1;
  126.     nn = nn + (nn + 1) / 2;
  127.     while(n < nn){
  128.       n *= 2;
  129.     }
  130.     mask = n - 1;
  131.     expand(n);
  132.     for(i=(0);i<(n);i++){
  133.       used[i] = 0;
  134.     }
  135.   }
  136.   inline int getHash(const int a){
  137.     unsigned long long d = a;
  138.     d = (((d * HashMap_ullP_L[0]) >> 32) * HashMap_ullP_L[1]) & mask;
  139.     return d;
  140.   }
  141.   inline int getHash(const unsigned a){
  142.     unsigned long long d = a;
  143.     d = (((d * HashMap_ullP_L[0]) >> 32) * HashMap_ullP_L[1]) & mask;
  144.     return d;
  145.   }
  146.   inline int getHash(const long long a){
  147.     unsigned long long d = a;
  148.     d = (((((d * HashMap_ullP_L[0]) >> 32) * HashMap_ullP_L[1]) >> 32) * HashMap_ullP_L[2]) & mask;
  149.     return d;
  150.   }
  151.   inline int getHash(const unsigned long long a){
  152.     unsigned long long d = a;
  153.     d = (((((d * HashMap_ullP_L[0]) >> 32) * HashMap_ullP_L[1]) >> 32) * HashMap_ullP_L[2]) & mask;
  154.     return d;
  155.   }
  156.   inline int getHash(const pair<int,int> a){
  157.     unsigned long long d = (((unsigned long long)a.first) << 32) + ((unsigned long long)a.second);
  158.     d = (((((d * HashMap_ullP_L[0]) >> 32) * HashMap_ullP_L[1]) >> 32) * HashMap_ullP_L[2]) & mask;
  159.     return d;
  160.   }
  161.   inline VAL& operator[](const KEY a){
  162.     int k = getHash(a);
  163.     for(;;){
  164.       if(used[k]==1 && key[k]==a){
  165.         break;
  166.       }
  167.       if(used[k]==0){
  168.         used[k] = 1;
  169.         key[k] = a;
  170.         break;
  171.       }
  172.       k = (k+1) & mask;
  173.     }
  174.     return val[k];
  175.   }
  176.   inline bool exist(const KEY a){
  177.     int k = getHash(a);
  178.     for(;;){
  179.       if(used[k]==1 && key[k]==a){
  180.         return true;
  181.       }
  182.       if(used[k]==0){
  183.         break;
  184.       }
  185.       k = (k+1) & mask;
  186.     }
  187.     return false;
  188.   }
  189.   template<class S> inline bool exist(const KEY a, S &res){
  190.     int k = getHash(a);
  191.     for(;;){
  192.       if(used[k]==1 && key[k]==a){
  193.         res = val[k];
  194.         return true;
  195.       }
  196.       if(used[k]==0){
  197.         break;
  198.       }
  199.       k = (k+1) & mask;
  200.     }
  201.     return false;
  202.   }
  203. }
  204. ;
  205. #define main dummy_main
  206. int main(){
  207.   wmem = memarr;
  208.   {
  209.     int i;
  210.     int j;
  211.     int k;
  212.     Rand rnd;
  213.     for(i=(0);i<(20);i++){
  214.       rnd.get(2);
  215.     }
  216.     for(i=(0);i<(4);i++){
  217.       for(j=(0);j<(32);j++){
  218.         k = rnd.get(1,62);
  219.         HashMap_ullP_L[i] |= (1ULL << k);
  220.       }
  221.       HashMap_ullP_L[i] |= (1ULL << 0);
  222.       HashMap_ullP_L[i] |= (1ULL << 63);
  223.     }
  224.   }
  225.   return 0;
  226. }
  227. #undef main
  228. int N;
  229. int A[100000];
  230. HashMap<int,int> hs;
  231. class Solution{
  232.   public:
  233.   int minOperations(vector<int>& target, vector<int>& arr){
  234.     int i;
  235.     dummy_main();
  236.     hs.init(target.size());
  237.     for(i=(0);i<(target.size());i++){
  238.       hs[target[i]] = i;
  239.     }
  240.     N = 0;
  241.     for(i=(0);i<(arr.size());i++){
  242.       if(hs.exist(arr[i])){
  243.         A[N++] = hs[arr[i]];
  244.       }
  245.     }
  246.     return target.size() - LIS_length(N, A);
  247.   }
  248. }
  249. ;
  250. // cLay version 20210103-1
  251.  
  252. // --- original code ---
  253. // #define main dummy_main
  254. // {}
  255. // #undef main
  256. // 
  257. // int N, A[1d5];
  258. // HashMap<int,int> hs;
  259. // 
  260. // class Solution {
  261. // public:
  262. //   int minOperations(vector<int>& target, vector<int>& arr) {
  263. //     dummy_main();
  264. //     hs.init(target.size());
  265. //     rep(i,target.size()) hs[target[i]] = i;
  266. //     N = 0;
  267. //     rep(i,arr.size()) if(hs.exist(arr[i])) A[N++] = hs[arr[i]];
  268. //     return target.size() - LIS_length(N, A);
  269. //   }
  270. // };
  271.  
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
compilation info 
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/8/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x20): undefined reference to `main'
collect2: error: ld returned 1 exit status
stdout
copy 
Standard output is empty
https://ideone.com/H7h14f
language:
C++ (gcc 8.3)
created:
3 years ago
visibility:
secret

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!