oj.uz

답안 #850915

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
850915 2023-09-17T18:55:21 Z Dextar 송신탑 (IOI22_towers) C++17
15 / 100
 4000 ms 27652 KB 
#include <cstdio>
#ifdef DEBUG
    #define D(X) X
#else
    #define D(X)
#endif
#include <bits/stdc++.h>
#define fr first
#define sc second
#define ll long long
#define pi 3.14159265359
#define pub push_back
#define pob pop_back
#define pari pair<int,int>
#define parli pair<long, long>

using namespace std;

const int INF = 1000 * 1000 * 1000;
const ll INF2 = 1LL * 1000 * 1000 * 1000 * 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;

bool comp(pari& v1, pari& v2)
{
    return v1.fr < v2.fr;
}


struct seg {
      vector<int> tree;
      int sz;

      void build(int n) {
          sz = 1;
          while(sz<n) {
              sz *= 2;
          }
          tree.resize(2*sz + 1, 0);
      }

      void clean()
      {
          for(int i=0; i<tree.size(); i++) {
              tree[i] = 0;
          }
      }

      void recSet(int idx, int lx, int rx, int i, int val) {
           if(rx-lx==1) {
               tree[idx] = val;
               return;
           }
           int mid = (lx+rx)/2;
           if(i<mid) {
               recSet(2*idx+1, lx, mid, i, val);
           } else
           {
               recSet(2*idx+2, mid, rx, i, val);
           }
           tree[idx] = max(tree[2*idx+1], tree[2*idx+2]);
      }

      void setX(int i, int val) {
          recSet(0, 0, sz, i, val);
      }

      int rec_range(int idx, int lx, int rx, int l, int r) {
          if(lx>=l&&rx<=r) {
              return tree[idx];
          }
          if(rx<=l||lx>=r) return 0;
          int mid = (lx+rx)/2;
          int left = rec_range(2*idx+1, lx, mid, l, r);
          int right = rec_range(2*idx+2, mid, rx, l, r);
          return max(left, right);
      }

      int range(int l, int r) {
          if(l>=r) {
             return 0;
          }
          return rec_range(0, 0, sz, l, r);
      }
};

struct seg2 {
      vector<int> tree;
      int sz;

      void build(int n) {
          sz = 1;
          while(sz<n) {
              sz *= 2;
          }
          tree.resize(2*sz + 1, INF);
      }

      void clean()
      {
          for(int i=0; i<tree.size(); i++) {
              tree[i] = INF;
          }
      }

      void recSet(int idx, int lx, int rx, int i, int val) {
           if(rx-lx==1) {
               tree[idx] = val;
               return;
           }
           int mid = (lx+rx)/2;
           if(i<mid) {
               recSet(2*idx+1, lx, mid, i, val);
           } else
           {
               recSet(2*idx+2, mid, rx, i, val);
           }
           tree[idx] = min(tree[2*idx+1], tree[2*idx+2]);
      }

      void setX(int i, int val) {
          recSet(0, 0, sz, i, val);
      }

      int rec_range(int idx, int lx, int rx, int l, int r) {
          if(lx>=l&&rx<=r) {
              return tree[idx];
          }
          if(rx<=l||lx>=r) return INF;
          int mid = (lx+rx)/2;
          int left = rec_range(2*idx+1, lx, mid, l, r);
          int right = rec_range(2*idx+2, mid, rx, l, r);
          return min(left, right);
      }

      int range(int l, int r) {
          return rec_range(0, 0, sz, l, r);
      }

      int low1(int idx, int lx, int rx, int l, int r, int val, int dir)
      {
           if(tree[idx]>=val||l>=rx||lx>=r) {
              if(dir==0)
                return -1;
              return INF;
           }
           if(rx-lx==1) {
               return lx;
           }
           int mid = (lx+rx)/2;
           int id1 = low1(2*idx+1, lx, mid, l, r, val, dir);
           int id2 = low1(2*idx+2, mid, rx, l, r, val, dir);
           if(dir==0) {
               return max(id1, id2);
           }
           return min(id1, id2);
      }

      int low1(int l, int r, int val, int dir)
      {
          return low1(0, 0, sz, l, r, val, dir);
      }
};


vector<int> dp;
seg mint, maxt, st2;
map<int, int> ord;
vector<int> h;
int res = 0;
int center = -1;
vector<int> pref, left1, right1, difh;
int qcnt = 1;
seg2 st1;


void init2(int l, int r, int d)
{
    int n = h.size();
    res = 0;
    for(int i=0; i<=n; i++) {
        dp[i] = 0;
    }
    vector<int> used(n+1, 0);
    vector<int> nums;
    for(int i=l; i<=r; i++) {
        int f1 = 0, f2 = 0;
        nums.pub(h[i]);
        nums.pub(h[i]-d);
        nums.pub(h[i]+d);
        if(i>l) {
            if(h[i]>=h[i-1]) {
                f1 = 1;
            } else
            {
                f1 = 2;
            }
        }
        if(i<r) {
            if(h[i]>=h[i+1]) {
                f2 = 1;
            } else
            {
                f2 = 2;
            }
        }
        if(f1==0) {
            f1 = f2;
        }
        if(f2==0) {
            f2 = f1;
        }
        if(f1==f2) {
            used[i] = f1;
        }
    }
    sort(nums.begin(), nums.end());
    ord.clear();
    ord[nums[0]] = 0;
    int sz = nums.size();
    for(int i=1; i<sz; i++) {
        if(nums[i]>nums[i-1]) {
            ord[nums[i]] = ord[nums[i-1]] + 1;
        } else
        {
            ord[nums[i]] = ord[nums[i-1]];
        }
    }
    mint.clean();
    maxt.clean();
    mint.build(sz);
    maxt.build(sz);

    for(int i=r; i>=l; i--) {
        if(used[i]==0) {
            continue;
        }
        if(used[i]==1&&h[i]-d>0) {
            dp[i] = mint.range(0, ord[h[i]-d] + 1);
            maxt.setX(ord[h[i]], dp[i]);
        }
        if(used[i]==2) {
            dp[i] = 1 + maxt.range(ord[h[i]+d], sz);
            mint.setX(ord[h[i]], dp[i]);
        }
        res = max(res, dp[i]);
    }
}


void init(int n, vector<int> h2)
{
    h.resize(n);
    for(int i=0; i<n; i++) {
        h[i] = h2[i];
    }
    dp.resize(n+1);
    int idx = 1;
    while(idx<n&&h[idx]>=h[idx-1]) {
        idx++;
    }
    center = idx - 1;
    while(idx<n&&h[idx]<=h[idx-1]) {
        idx++;
    }
    pref.resize(n+1);
    pref[0] = 0;
    for(int i=1; i<=n; i++) {
        pref[i] = pref[i-1];
        if(i>1&&i<n) {
            if(h[i-1]<h[i-2]&&h[i-1]<h[i]) {
                pref[i]++;
            }
        } else if(i>1)
        {
            if(h[i-1]<h[i-2]) {
                pref[i]++;
            }
        } else
        {
            if(h[i-1]<h[i]) {
                pref[i]++;
            }
        }
    }
    if(idx==n) {
        return;
    }
    center = -1;
    init2(0, n - 1, 1);
    left1.resize(n, INF);
    right1.resize(n, -1);
    /*
    for(int i=0; i<n; i++) {
        a[i] = {h[i], i};
    }
    sort(a.begin(), a.end(), comp);
    */
    st1.build(n);
    st2.build(n);
    for(int i=0; i<n; i++) {
        st1.setX(i, h[i]);
        st2.setX(i, h[i]);
    }
    difh.resize(n);
    for(int i=0; i<n; i++) {
        pari p = {h[i], i};
        left1[p.sc] = st1.low1(0, p.sc, p.fr, 0);
        right1[p.sc] = st1.low1(p.sc + 1, n, p.fr, 1);
        int h1 = 2*INF+10, h2 = h1;
        if(left1[p.sc]!=-1) {
            h1 = st2.range(left1[p.sc]+1, p.sc);
        }
        if(right1[p.sc]!=INF) {
            h2 = st2.range(p.sc+1, right1[p.sc]);
        }  //cout<<h1<<endl;
        difh[p.sc] = min(h1, h2) - p.fr;
    }
    sort(difh.begin(), difh.end());
}

int max_towers(int l, int r, int d)
{
    int n = h.size();
    if(n==1) {
        return 1;
    }
    if(l==r) {
        return 1;
    }
    if(center!=-1) {
        if(r<=center||l>=center) {
            return 1;
        }
        if(h[center]-h[l]>=d&&h[center]-h[r]>=d) {
            return 2;
        }
        return 1;
    }
    if(d==1) {
        int ans = pref[r] - pref[l+1];
        if(h[l]<h[l+1]) {
            ans++;
        }
        if(h[r]<h[r-1]) {
            ans++;
        }
        return ans;
    }
    if(qcnt==1) {
        qcnt = 7;
        init2(l, r, d);
        return res;
    }
    /*
    for(int i=0; i<n; i++) {
        //cout<<left1[i]<<" ";
        //cout<<right1[i]<<" ";
        //cout<<difh[i]<<" ";
    }
    //cout<<endl;
    */
    if(l==0&&r==h.size()-1) {
        int lo = 0, hi = n - 1;
        while(lo<=hi) {
            int mid = (lo+hi)/2;
            if(difh[mid]>=d) {
                hi = mid - 1;
            } else
            {
                lo = mid + 1;
            }
        }
        return n - lo;
    }

    return res;
}

/*
7
10 20 60 40 50 30 70
*/

/*
int main()
{
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    //D(freopen("input.txt","r",stdin);)
    //D(freopen("ouput.txt","w",stdout);)
    int t = 1;
    //cin >> t;
    loop:
    while(t--)
    {
        int n;
        cin >> n;
        vector<int> a(n);
        for(int i=0; i<n; i++) {
            cin >> a[i];
        }
        init(n, a);
        int res = max_towers(0, 6, 10);
        if(res==0) {
            res = 1;
        }
        cout << res;
    }
    return 0;
}
*/

Compilation message

towers.cpp: In member function 'void seg::clean()':
towers.cpp:43:25: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   43 |           for(int i=0; i<tree.size(); i++) {
      |                        ~^~~~~~~~~~~~
towers.cpp: In member function 'void seg2::clean()':
towers.cpp:100:25: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  100 |           for(int i=0; i<tree.size(); i++) {
      |                        ~^~~~~~~~~~~~
towers.cpp: In function 'int max_towers(int, int, int)':
towers.cpp:362:15: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long unsigned int'} [-Wsign-compare]
  362 |     if(l==0&&r==h.size()-1) {
      |              ~^~~~~~~~~~~~

Subtask #1
4.0 / 4.0

# 결과 실행 시간 메모리 Grader output
1 Correct 291 ms 1444 KB Output is correct
2 Correct 533 ms 2372 KB Output is correct
3 Correct 510 ms 2364 KB Output is correct
4 Correct 583 ms 2624 KB Output is correct
5 Correct 546 ms 2364 KB Output is correct
6 Correct 551 ms 2364 KB Output is correct
7 Correct 551 ms 2368 KB Output is correct
8 Correct 0 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 0 ms 344 KB Output is correct

Subtask #2
11.0 / 11.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 548 KB Output is correct
2 Correct 29 ms 948 KB Output is correct
3 Correct 25 ms 972 KB Output is correct
4 Correct 26 ms 968 KB Output is correct
5 Correct 26 ms 968 KB Output is correct
6 Correct 25 ms 952 KB Output is correct
7 Correct 30 ms 940 KB Output is correct
8 Correct 0 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 14 ms 940 KB Output is correct
11 Correct 14 ms 956 KB Output is correct
12 Correct 1 ms 344 KB Output is correct
13 Correct 1 ms 344 KB Output is correct
14 Correct 1 ms 344 KB Output is correct
15 Correct 25 ms 944 KB Output is correct
16 Correct 25 ms 924 KB Output is correct
17 Correct 25 ms 912 KB Output is correct
18 Correct 1 ms 344 KB Output is correct
19 Correct 14 ms 936 KB Output is correct
20 Correct 25 ms 920 KB Output is correct
21 Correct 28 ms 936 KB Output is correct
22 Correct 25 ms 940 KB Output is correct
23 Correct 1 ms 344 KB Output is correct
24 Correct 14 ms 1200 KB Output is correct
25 Correct 5 ms 600 KB Output is correct
26 Correct 27 ms 976 KB Output is correct
27 Correct 29 ms 980 KB Output is correct
28 Correct 27 ms 976 KB Output is correct
29 Correct 27 ms 976 KB Output is correct
30 Correct 27 ms 976 KB Output is correct
31 Correct 26 ms 972 KB Output is correct
32 Correct 0 ms 344 KB Output is correct
33 Correct 0 ms 344 KB Output is correct
34 Correct 14 ms 1000 KB Output is correct
35 Correct 15 ms 996 KB Output is correct

Subtask #3
0 / 12.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 548 KB Output is correct
2 Correct 29 ms 948 KB Output is correct
3 Correct 25 ms 972 KB Output is correct
4 Correct 26 ms 968 KB Output is correct
5 Correct 26 ms 968 KB Output is correct
6 Correct 25 ms 952 KB Output is correct
7 Correct 30 ms 940 KB Output is correct
8 Correct 0 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 14 ms 940 KB Output is correct
11 Correct 14 ms 956 KB Output is correct
12 Correct 1 ms 344 KB Output is correct
13 Correct 1 ms 344 KB Output is correct
14 Correct 1 ms 344 KB Output is correct
15 Correct 25 ms 944 KB Output is correct
16 Correct 25 ms 924 KB Output is correct
17 Correct 25 ms 912 KB Output is correct
18 Correct 1 ms 344 KB Output is correct
19 Correct 14 ms 936 KB Output is correct
20 Correct 25 ms 920 KB Output is correct
21 Correct 28 ms 936 KB Output is correct
22 Correct 25 ms 940 KB Output is correct
23 Correct 1 ms 344 KB Output is correct
24 Correct 14 ms 1200 KB Output is correct
25 Correct 5 ms 600 KB Output is correct
26 Correct 27 ms 976 KB Output is correct
27 Correct 29 ms 980 KB Output is correct
28 Correct 27 ms 976 KB Output is correct
29 Correct 27 ms 976 KB Output is correct
30 Correct 27 ms 976 KB Output is correct
31 Correct 26 ms 972 KB Output is correct
32 Correct 0 ms 344 KB Output is correct
33 Correct 0 ms 344 KB Output is correct
34 Correct 14 ms 1000 KB Output is correct
35 Correct 15 ms 996 KB Output is correct
36 Execution timed out 4034 ms 16664 KB Time limit exceeded
37 Halted 0 ms 0 KB -

Subtask #4
0 / 14.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4013 ms 27652 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #5
0 / 17.0

# 결과 실행 시간 메모리 Grader output
1 Execution timed out 4038 ms 7756 KB Time limit exceeded
2 Halted 0 ms 0 KB -

Subtask #6
0 / 19.0

# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 548 KB Output is correct
2 Correct 29 ms 948 KB Output is correct
3 Correct 25 ms 972 KB Output is correct
4 Correct 26 ms 968 KB Output is correct
5 Correct 26 ms 968 KB Output is correct
6 Correct 25 ms 952 KB Output is correct
7 Correct 30 ms 940 KB Output is correct
8 Correct 0 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 14 ms 940 KB Output is correct
11 Correct 14 ms 956 KB Output is correct
12 Correct 1 ms 344 KB Output is correct
13 Correct 1 ms 344 KB Output is correct
14 Correct 1 ms 344 KB Output is correct
15 Correct 25 ms 944 KB Output is correct
16 Correct 25 ms 924 KB Output is correct
17 Correct 25 ms 912 KB Output is correct
18 Correct 1 ms 344 KB Output is correct
19 Correct 14 ms 936 KB Output is correct
20 Correct 25 ms 920 KB Output is correct
21 Correct 28 ms 936 KB Output is correct
22 Correct 25 ms 940 KB Output is correct
23 Correct 1 ms 344 KB Output is correct
24 Correct 14 ms 1200 KB Output is correct
25 Correct 5 ms 600 KB Output is correct
26 Correct 27 ms 976 KB Output is correct
27 Correct 29 ms 980 KB Output is correct
28 Correct 27 ms 976 KB Output is correct
29 Correct 27 ms 976 KB Output is correct
30 Correct 27 ms 976 KB Output is correct
31 Correct 26 ms 972 KB Output is correct
32 Correct 0 ms 344 KB Output is correct
33 Correct 0 ms 344 KB Output is correct
34 Correct 14 ms 1000 KB Output is correct
35 Correct 15 ms 996 KB Output is correct
36 Execution timed out 4034 ms 16664 KB Time limit exceeded
37 Halted 0 ms 0 KB -

Subtask #7
0 / 23.0

# 결과 실행 시간 메모리 Grader output
1 Correct 291 ms 1444 KB Output is correct
2 Correct 533 ms 2372 KB Output is correct
3 Correct 510 ms 2364 KB Output is correct
4 Correct 583 ms 2624 KB Output is correct
5 Correct 546 ms 2364 KB Output is correct
6 Correct 551 ms 2364 KB Output is correct
7 Correct 551 ms 2368 KB Output is correct
8 Correct 0 ms 344 KB Output is correct
9 Correct 1 ms 344 KB Output is correct
10 Correct 0 ms 344 KB Output is correct
11 Correct 2 ms 548 KB Output is correct
12 Correct 29 ms 948 KB Output is correct
13 Correct 25 ms 972 KB Output is correct
14 Correct 26 ms 968 KB Output is correct
15 Correct 26 ms 968 KB Output is correct
16 Correct 25 ms 952 KB Output is correct
17 Correct 30 ms 940 KB Output is correct
18 Correct 0 ms 344 KB Output is correct
19 Correct 1 ms 344 KB Output is correct
20 Correct 14 ms 940 KB Output is correct
21 Correct 14 ms 956 KB Output is correct
22 Correct 1 ms 344 KB Output is correct
23 Correct 1 ms 344 KB Output is correct
24 Correct 1 ms 344 KB Output is correct
25 Correct 25 ms 944 KB Output is correct
26 Correct 25 ms 924 KB Output is correct
27 Correct 25 ms 912 KB Output is correct
28 Correct 1 ms 344 KB Output is correct
29 Correct 14 ms 936 KB Output is correct
30 Correct 25 ms 920 KB Output is correct
31 Correct 28 ms 936 KB Output is correct
32 Correct 25 ms 940 KB Output is correct
33 Correct 1 ms 344 KB Output is correct
34 Correct 14 ms 1200 KB Output is correct
35 Correct 5 ms 600 KB Output is correct
36 Correct 27 ms 976 KB Output is correct
37 Correct 29 ms 980 KB Output is correct
38 Correct 27 ms 976 KB Output is correct
39 Correct 27 ms 976 KB Output is correct
40 Correct 27 ms 976 KB Output is correct
41 Correct 26 ms 972 KB Output is correct
42 Correct 0 ms 344 KB Output is correct
43 Correct 0 ms 344 KB Output is correct
44 Correct 14 ms 1000 KB Output is correct
45 Correct 15 ms 996 KB Output is correct
46 Execution timed out 4034 ms 16664 KB Time limit exceeded
47 Halted 0 ms 0 KB -