Submission details
Task:Entrepreneur
Sender:aalto25a_005
Submission time:2025-09-03 21:34:29 +0300
Language:C++ (C++11)
Status:READY
Result:ACCEPTED
Test results
testverdicttime
#1ACCEPTED0.00 sdetails
#2ACCEPTED0.00 sdetails
#3ACCEPTED0.00 sdetails
#4ACCEPTED0.00 sdetails
#5ACCEPTED0.00 sdetails
#6ACCEPTED0.00 sdetails
#7ACCEPTED0.00 sdetails
#8ACCEPTED0.09 sdetails
#9ACCEPTED0.15 sdetails
#10ACCEPTED0.24 sdetails
#11ACCEPTED0.01 sdetails
#12ACCEPTED0.00 sdetails
#13ACCEPTED0.00 sdetails
#14ACCEPTED0.00 sdetails
#15ACCEPTED0.00 sdetails

Compiler report

input/code.cpp: In function 'std::pair<long unsigned int, long unsigned int> prep(uint64_t, std::vector<long unsigned int>&)':
input/code.cpp:19:17: warning: unused variable 'ii' [-Wunused-variable]
   19 |   for (uint64_t ii = func(mi, machi); func(ma, machi) < carCount;) {
      |                 ^~
input/code.cpp: In function 'int main()':
input/code.cpp:55:8: warning: structured bindings only available with '-std=c++17' or '-std=gnu++17'
   55 |   auto [mi, ma] = prep(carCount, machi);
      |        ^

Code

#include <cstdint>
#include <iostream>
#include <utility>
#include <vector>

uint64_t func(uint64_t tim, std::vector<uint64_t> &machi) {
  uint64_t ret = 0;
  for (uint64_t ii = 0; ii < machi.size(); ii++) {
    ret += tim / machi[ii];
  }
  return ret;
}

std::pair<uint64_t, uint64_t> prep(uint64_t carCount,
                                   std::vector<uint64_t> &machi) {
  uint64_t mi = 0;
  uint64_t ma = 1;

  for (uint64_t ii = func(mi, machi); func(ma, machi) < carCount;) {
    // std::cout << ma << std::endl;
    mi = ma;
    ma *= 2;
  }
  return std::pair<uint64_t, uint64_t>(mi, ma);
}
uint64_t run(uint64_t mi, uint64_t ma, uint64_t carCount,
             std::vector<uint64_t> &machi) {
  uint64_t mid = (mi + ma) / 2;
  while (ma - mi != 1) {
    uint64_t aa = func(mid, machi);
    if (aa < carCount) {
      mi = mid;
    } else {
      ma = mid;
    }
    mid = (mi + ma) / 2;
  }
  return ma;
}

int main() {
  uint64_t count = 0;
  uint64_t carCount = 0;
  std::cin >> count;
  std::cin >> carCount;
  // std::cout << count << " " << carCount << std::endl;
  //   std::cout << count << std::endl;
  std::vector<uint64_t> machi(count);
  for (uint64_t ii = 0; ii < count; ii++) {
    uint64_t i;
    std::cin >> i;
    machi[ii] = i;
  }

  auto [mi, ma] = prep(carCount, machi);
  // std::cout << mi << " " << ma << std::endl;
  uint64_t ret = run(mi, ma, carCount, machi);
  std::cout << ret << std::endl;
  return 0;
}

Test details

Test 1

Verdict: ACCEPTED

input
10 10
6 5 1 2 1 5 10 4 6 6

correct output
4

user output
4

Test 2

Verdict: ACCEPTED

input
10 10
6 6 4 3 4 9 3 2 6 10

correct output
6

user output
6

Test 3

Verdict: ACCEPTED

input
10 10
5 4 10 7 8 4 1 8 9 2

correct output
5

user output
5

Test 4

Verdict: ACCEPTED

input
1 1000000000
1

correct output
1000000000

user output
1000000000

Test 5

Verdict: ACCEPTED

input
1 1000000000
1000000000

correct output
1000000000000000000

user output
1000000000000000000

Test 6

Verdict: ACCEPTED

input
1000 1000
271 687 392 992 11 410 702 870...

correct output
223

user output
223

Test 7

Verdict: ACCEPTED

input
1000 1000
598 523 703 794 737 689 724 26...

correct output
282

user output
282

Test 8

Verdict: ACCEPTED

input
200000 1000000000
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ...

correct output
5000

user output
5000

Test 9

Verdict: ACCEPTED

input
200000 1
760045594 599341056 300698860 ...

correct output
8214

user output
8214

Test 10

Verdict: ACCEPTED

input
200000 1000000000
33941840 210038922 596070148 7...

correct output
371045814100

user output
371045814100

Test 11

Verdict: ACCEPTED

input
25 1000000000
1000000000 1 1 1 1 1 1 1 1 1 1...

correct output
41666667

user output
41666667

Test 12

Verdict: ACCEPTED

input
12 1000000000
1 1 1 1 1 1 1 1 1 1 1 10000000...

correct output
90909091

user output
90909091

Test 13

Verdict: ACCEPTED

input
23 1000000000
1000000000 1000000000 10000000...

correct output
43478261000000000

user output
43478261000000000

Test 14

Verdict: ACCEPTED

input
23 1000000000
1000000000 1000000000 10000000...

correct output
43478261000000000

user output
43478261000000000

Test 15

Verdict: ACCEPTED

input
3 3
10 11 12

correct output
12

user output
12