The 2026 Universal Cup Finals Challenge Roadshow

追加: 2026-05-12

[00:00:00]Hello everyone. Welcome back to the next section ro. Uh our ro will begin soon after 10 minutes. Yeah. So please take your cell phone into the silent mall.

[00:00:12]And and there also so many empty in the front row so you can go take a seat in the front row.

[00:00:30]>> [music] [music] >> Heat. Heat.

[00:00:42][music] >> [music] [music] [music] [music] >> Heat. Heat.

[00:01:10][music] Heat.

[00:01:16][music] [music] HEAT. [music] HEAT.

[00:01:36][music] HEAT.

[00:01:49][music] >> [music] [music] [music] >> HEAT. HEAT.

[00:02:16][music] >> [music] >> HEAT.

[00:02:32][music] HEAT.

[00:02:45]>> [music] [music] >> HEAT.

[00:03:00][music] [music] HEY, HEAT.

[00:03:10]>> [music] [music] [music] >> YEAH, I've started my computer programming journey uh when I was a junior high and my first aim was to uh win gold in II. Uh then when I entered university, my goal was to win gold in ICPC. I think I've started competitive programming at around like 2011. I won ICBC world finals in 2018 and 2019.

[00:03:44][music] Scratch [music] and I started doing them actually quite a while ago which is 15 years already.

[00:04:09]I'm the youngest. I'm doing comeic programming [music] for 11 years. At some point you come across uh like a branch of math which is programming and you decide that it's it's interesting, [music] it's nice, you try it and maybe you discover that you're good at it.

[00:04:25]I've been doing competitive programming for quite a while now um since I was [music] uh seven or 8 years old. I started uh mostly because my parents are programmers and they just felt like I mean I was probably good at math but I didn't wasn't doing math Olympics of course but uh they decided that [music] like I can try and like see what what goes. I started competitive programming in my third grade of the high school.

[00:04:50][music] I study statistics at my university and I have interest in the in finance. So in my future I I will study about finance more than programming but I I like to do competitive programming because [music] uh puzzle and mathematical things of the this is very fun.

[00:05:23]I think ICPC teaches you how to uh solve problems in general like problem solving skills and also how to do things fast even if for example you're doing coding interview or [music] just doing work at work it actually I think uh indirectly helps you and I think I observed some cases where I think people could have benefit from having some uh sort of background like I Yeah. And I I do think that it competitive programming experience helps you to like go to faster to like create some like starting point [music] to like create some code quickly and to get it working. Also, it helps you to be like more careful with [music] like some corner cases because you in competitive programming you want your code to like always work on all test cases. [music] I just enjoy problems. Of course, I enjoy winning, but uh even if I can't win, uh I still can enjoy computer programming. So, I'll keep I'm involved in this community.

[00:06:28]>> One uh definitely important thing is that uh competitive programming problems are challenging and they are like being pro progressively better at [music] them. Yeah, I think uh performing under pressure is another factor that can become uh important in life at various points and I think it's generally competitive programming experience [music] is very useful for high frequency trading because like you want to test a lot of ideas and [music] you want to do it quickly and that's precisely what is like very good what competitive programming trains [music] you to do.

[00:07:16]pure job of solving interesting problems and work in the team. So now it's an outside event. I'm really happy to be here because usually we even in a team we participate in contest remotely and it's not the same experience [music] but uh anyway I think a lot of engineering skills indeed like uh there's a lot to gain and [music] um especially like if you are looking for like different ways to do it like I think you can learn a lot from other people and uh [music] for example often when you do competitions you can learn the approaches of other people or like how they handle there like code or like ideas and that's uh very valuable.

[00:07:58][music] >> I will just stay close to [music] just theoretical research.

[00:08:06]>> I'm now working on cotlin programming language compiler.

[00:08:10]I'm quite happy with what I'm doing [music] and don't have any plans for big changes.

[00:08:15]>> I did a research math degree after just right after my ICPC uh [music] last event. So um that's possibility to return to I didn't get a PhD.

[00:08:45]Well, I work in physics. I'm an experimental physicist.

[00:08:48]>> I am a bachelor student [music] and right now I really want to keep studying and pursue a [music] master's degree and maybe something even further.

[00:09:03]>> [music] >> world.

[00:09:08]For me personally, it would be cool to be [music] on on the cutting edge of technology.

[00:09:43]Hello everyone. Welcome back to the 2026 Universal Cup final challenge. There is the RO section and please take your seats as soon as possible.

[00:09:55]Please take your seat. Okay, I'm li from Huawei contact management departments.

[00:10:02]Uh in this section I will uh welcome some uh we I will invite some team that had participants the challenge contest to share their idea their code or their uh other in uh extra information about this challenge problem. share how to solve it, how they are thinking and in in this computer uh you can use this computer share the code that you have submit during the con competition for example. Oh, sorry. Uh, like this.

[00:10:43]And and of course, you can use this uh path to uh X some not annotate.

[00:10:54]Yes, like like this. You can use this to annotate.

[00:10:59]Okay. So, it we are ready. So, we let's begin. And the first team is the uh dos pro tips virtual.

[00:11:14]Where are you? Are you here? Dot dot uh properties virtual the team.

[00:11:28]Okay. Welcome You need to use mics or or this mic.

[00:11:44]>> You need to use this m or this >> one.

[00:11:49]You can use this.

[00:11:58]I don't remember which one.

[00:12:01]Okay.

[00:12:02]Thank you.

[00:12:07]>> Okay. Thank you.

[00:12:20]>> Okay. So we started with pretty uh easy solution that actually I think uh replicated as a baseline.

[00:12:32]Let me see.

[00:12:35]Yeah. And um well our function for scheduling were pretty pretty slow.

[00:12:45]Uh can schedule worked in linear time.

[00:12:48]It was pretty slow. It's got a lot of time limits. So we change it to [snorts] to the segment tree which is still pretty slow and that's how we got lucky that this one was pretty slow because because it was pretty slow we come up with idea what if we wouldn't try each current task for each GPU at each second and instead that uh what if we will uh stop trying after we get like some number of rejects and that how we got our first uh submission over 360 million but just skipping after first 20 times that we couldn't find a place for a request.

[00:13:56]Then we just fiddled with a starting function. For example, here we sorted by two times uh L E plus L out times allowed. In the end, we used three times LI + 2 times allowed uh times allowed. And uh we changed our skips to 35 I think. And that was ideal.

[00:14:22]That's all.

[00:14:31]Uh uh please hello. Please keep uh anyone has some question or discuss with him.

[00:14:41]Okay. I have question uh sorry I have questions. Uh it seemed that most of the teams have used the language C++ but you use the the rust.

[00:14:52]>> Yes. Why? Uh well me and Baris both use Rust in our competitive programming.

[00:14:59]>> Uh okay just for me there.

[00:15:01]>> So we just use Rust because of that.

[00:15:03]>> Okay. Okay. Thank you. Thank you. Okay.

[00:15:05]Just take a seat.

[00:15:11]Okay.

[00:15:19]Um, now let's uh invite the next teams.

[00:15:24]Uh, let me check. Uh, uh, the next team is, uh, Arvin and Arrow Gam.

[00:15:35]Arvin and Aran.

[00:15:38]That's welcome.

[00:15:47]>> You need to take this phone or this one.

[00:15:51]>> Okay.

[00:15:52]>> Yeah, you can use this one to annotate.

[00:15:58]>> This way.

[00:15:58]>> No, I think it's like a pencil. Oh, >> there is the pencil. There is >> there is pencil. I think you should talk about how you optimize the >> baseline first.

[00:16:08]>> Yeah. Uh okay. So the first thing we did is try to implement the baseline.

[00:16:16]I'm not sure if I can uh okay this is my typical time t which has nothing to do with the >> problem.

[00:16:27]Right. So we implemented the baseline and then we right the most obvious solution is just maintain a like six VN integer array for each GPU. Uh that is quite slow. So we use the use a different method. We for each GPU we store all the actual events and then we do a linear brute forces and that was fast enough to pass the tests like even though it's like not very optimized but I think in a like five hour contest is like good enough fast enough for our purpose right so that's the first thing and then the second and then the second thing is we realize we don't really have much good ideas so we look at how the baseline like how many places in the baseline that we can like change and I realize I I think we have really have two places to change uh which we can put right so there are two choices there are two things we can do what is a GPU choice uh which is uh okay the baseline is smallest index and we can see that we have a few options take a random take a like counting by minimum schedule something uh okay and the second very important options is sorting uh it's about how we choose prioritize task to sort uh uh to use right so we just experimented with a lot of options of uh how to sort the like how what's the value of pity given to each of the tasks. So okay here's like the yes the configurations we have like a few parameters uh yeah like can write a formula out and then we kind of just optimize all the parameters here >> right okay so [laughter] okay so after we know that uh we realize that for different kind of parameters they do well on different testers on the very different testes so we just like invent a strategy to like find out which case is it? And then we do some offline uh data analysis to take all the to take a performance of each configuration and then we just uh use the best configuration on each of the test cases, right? And end up we end up using like >> oh uh uh the screen isn't updating.

[00:18:54]>> You can use this back to >> Oh, okay. Right. So we hardcoded some of the hashes and then hardcoded which strategies are best. Uh they have uh end up using like 10 to 20 strategies here.

[00:19:06]Uh those those are here like right. So for example like alpha 0.1 retune one of the alphas values and then [laughter] and a few choices. Okay this is all 100 of them. Anyways yeah this uh we do we did this in uh python in pandas. So yeah >> you might be wondering how do we get the hash of the test case. Apparently you can do exit program and it prints the exit exit number. So this gives you like eight bits.

[00:19:34]>> So we did that twice and we got 16 bits and this was enough to like separate almost all test cases. Also there might be a bug with the testing cuz like we used cotlin and we had 14 second time limit. So like we might have like got more points from like 14 second time limit.

[00:19:52]Yeah.

[00:20:02]Uh unfortunately we are not very smart cuz like there is better sorting algorithms because we use like only linear terms but apparently like this is very strong like oh wait can I annotate like apparently oh yeah >> wait what Okay. Like apparently this sorting is very good, but we didn't try it because you're not very smart.

[00:20:34]Uh apparently like so if you set alpha equals 0.2 and beta equals 1, like this is just the area of like the tokens you use. But apparently a very good strategy like a very like good strategy was apparently this like some other team told us that but yeah but but it was just like train on test hyperparameters.

[00:20:57]Yeah.

[00:21:00]Okay. Anyone has question to then anyone has question okay I have a question because you are you are then another team they did not use the C++ >> so what's the qu what's the reason you use the cotling >> right so in general I do competitive programming in cotlin but for this particular contest it's actually not a good choice but because I'm the only person in the team that can call cotlin when they code C++ right so I'm being so basically I have to code for the whole five hours and it was quite exhausting at the end in fact I made quite a few mistakes uh for the last few submissions I did like incorrect configurations or like I I just have a buck like many bucks for yeah and so our last hour didn't end very well so it was not a good choice in this particular situation >> so how how's the teammates seeing you cannot see >> can you see see see the debug.

[00:22:02]>> Yeah. So in this I guess for this particular context that's fine because our strategy is very simple. It's just like most of the core logic is not in the call in mostly on the like choosing the configurations or like thinking of what other options to try. So on this side is like the language barrier isn't very important right.

[00:22:23]>> Okay. Thank you. Thank you.

[00:22:32]Okay.

[00:22:34]Okay. Just just put Okay.

[00:22:41]Okay. Let's uh invite the next team.

[00:22:47]The next team is uh after life after light. Welcome.

[00:23:08]Hello. Uh hello.

[00:23:11]Which one is the Hello. Okay. Uh so I'm going to try to introduce our solutions and hopefully my baby English can handle all of this. I even write a script for this. Uh which one is the highest submission? I think it's this one.

[00:23:31]So uh uh basically we are trying to uh uh decide whether to uh start uh a task in each second and uh when handling we're handling a problem of maintain GPU memory usage on each memory. we directly maintain all events on every GPU and uh and uh simulate these events to check whether a task could be could be allocated to a given GPU. Uh so uh notice all events in one certain GPU and uh we we are trying to check whether a new new task can be assigned to this GPU and by uh by simulating all these events and check whether uh sometime the memory usage is out of the limit. Uh and for task allocation we our basic idea it is greedy that is to scan all unallocated task in a certain order and scan all GPUs in a certain order. Uh I will try to find all these codes. Yeah. So uh the weighted list means on uh unallocated tasks and uh it is sorted in a certain order where we try to uh try to use some different task score to uh to to to to sort them and assign the task once we found a GPU that could accommodate it.

[00:24:58]So we both sort task and GPUs and for task ordering we use the total GPU memory usage as the sorting uh as as sorting method uh namely as the uh uh is quite similar to the previous team and we also try some uh different usage of the of the scoring function but it all runs very badly and for GPU ordering we designed a score based on the remaining GPU memory and remaining task cap capity and the and events corresponding to the last ending task and and and this is maybe the the GPU scoring and the overall idea was to distribute task more evenly and avoid the long tail issues and at first the solution could not uh produce results within the required time limit. So uh we try to do some uh constant work on this code and uh most important thing is to uh we find something when we find someone uh some task uh which is cannot assign to uh any GPU and we uh and we count the number of this kind of task and uh when the number exceeds our memory we just stop the simulating for this second and we just set all other task as uh non assign. and uh to assign this task in the following seconds and uh this is a quite a important I don't know whether it works but I don't know why it works but it just works and it's uh improved the score very significantly and uh the last uh the the last thing we did is to uh try to adjust all the all the paramets and try to find some uh more more accurate paramet uh for for for the task. Uh we didn't figure out that we can use something like exit code to get the get the exact uh uh exact data or the hash value of the data for each test case. Uh so we try to uh uh uh find the uh accurate uh parameal accurate uh final pyramid. So uh this is our code. Yeah. And that's all.

[00:27:23]>> Okay. Anyone take questions?

[00:27:26]Okay.

[00:27:30]>> So So please go back to the uh 127 line.

[00:27:34]>> 127.

[00:27:35]>> Yeah. So uh how did you decide the number 18? So what's the the the the meaning of the bad?

[00:27:42]>> The bad means uh in the current second.

[00:27:46]So we just to uh scan all the unassigned tasks and try to put it in some certain GPU and when when test uh cannot be put in any GPU we just mark it bad and count all the number of bads and when it exceeds some uh the like the number 18 when it exceeds 18 uh we just uh stop the seconds and set all other tasks to be to so we let all other tasks to assign in the folder seconds not in this second and the number 18 was from by testing all the numbers. So we it it initially it was three and we increase the number and the score is increasing so we increased until it gets 18.

[00:28:31]>> Okay. So it's just by experience.

[00:28:33]>> Yeah, by experience.

[00:28:34]>> Okay. Thank you.

[00:28:38]>> Any other questions?

[00:28:42][snorts] >> Okay, thanks uh after live. Thank you.

[00:28:47]And okay, let's invite the next team.

[00:28:50]The next team is uh probe transform.

[00:28:56]Okay.

[00:29:10]So okay. So uh firstly we have done the we have find the hash for each case.

[00:29:24]Uh also we had two comparators.

[00:29:27]First comparators is by consumate memory and second comparator is by the time that task like we have uh we can have two bottlenecks either it's a consumate memory uh either this running time of tasks so it's either memory or b in the statement uh where is the second this is the second comparator uh so uh we are sourcing GPUs in some Uh I think it's not like we know that in first 40 cases K equals 4 in the next 30 cases K equals 1 and the other cases K is like a big number.

[00:30:13]So uh so all cases where the solution got good score is cases with K equal one.

[00:30:22]uh and so for this case the sourcing of uh GPUs is not important so so we just shuffle them uh also we I think is it it's our best submission uh I think here we change it uh division by two to 0.6 six. Uh maybe if we tried with several alphas, we'll got a better score. I don't know. So, but actually it was like our implementation of baseline worked in 6.7 or something like this out of 7 seconds. So, uh so it was hard to push baseline by time limit. Yeah, it's okay. That's all.

[00:31:15]>> Okay. Any question to then any question?

[00:31:21]Uh okay. I have questions that uh in the 122 line you use the text hashi to it seem that is uh uh corresponding to a specific text case or >> yes it's case 68. It's test case 50 something. I don't remember >> how >> like it's the test cases where this comparator got better score than this.

[00:31:48]>> Oh okay. Okay.

[00:31:55]Okay. Any other question?

[00:31:59]Okay. So >> and we also used the exit code to determine the hs.

[00:32:07]>> Yeah. So >> in the beginning it was like here in the pre not previous submission but some submission it was here exit test hash >> uh >> or here here uh you try uh try a hashes recognize the text case. Okay I got it.

[00:32:28]Okay thank thank you thank you very much.

[00:32:34]Uh and the next team is USA1.

[00:32:41]Welcome Um hi everyone.

[00:33:14]So for our team what we did is um well first of all we started with the baseline same as most teams. Then the first thing you want to do is you want to just change the formula in the baseline so that basically the tasks that are cheaper um or like that require less resources overall uh are used first and then um but I think the idea that uh maybe did not uh no no one mentioned the other thing is that uh so in general if you knew all the tasks from the beginning if you the whole set of tasks that you need to execute. Then instead of just going greedily so like at every step trying to get some new tasks and uh like finding which task to execute at this time stamp and then just go to the next time stamp is not as good as uh if you instead try to build the whole schedule. So if there was some way to optimize the whole schedule of the thing uh then uh you can get at least in theory you can get better results. um because um you can directly optimize the objective function from the problem instead of just having some heristic function that you're trying to optimize on each time stamp separately because in the latter case it's less clear that you're actually optimizing the right thing, right? But you you can of course experiment with different functions, but um it's not so direct. Um yeah. So basically you can sort still like sort the tasks in the order of um um the sumistic function but then you can uh basically instead of trying to just going through the tasks one by one and adding them to the current time stamp, you go through them one by one but you try to add them to the earliest possible timestamp from now in the future. um so that no resources are overflowing in on any GPU and uh so you go through each task and you just put it somewhere in the future and then now you can take the permutation of tasks that you got at the beginning and you can evaluate it. So you can basically find the score that you can get for this permutation and now you can optimize this permutation so that you can try to swap two elements or you can try to take one element or like one task and move it to a different place in the permutation and re-evaluate and if it gets a better result then you can keep it there. Um so we had some code that did all of that.

[00:35:56]Um so well yeah unfortunately it was not used but anyway um the the this idea I think in general is a good idea because like you can so basically what you can do is you can just optimize something every time stamp like when you have some set of tasks that are current and like you need to schedule them you just build the whole schedule from from from scratch and then you just follow the schedule until at some point you will get a new task, right? And when you get a new task, you can just rebuild the schedule from scratch again and so on.

[00:36:34]And in theory, I think this is a very good approach. I think in practice, the main problem is that it's of course much slower than the uh greedy approach or any other approach I guess presented before. And the problem is that there were some small test cases in the set of all test cases. I think the first 50 were maybe pretty small, but I think also their influence on the score was not that big. So in the end, we didn't really use any kind of optimization like this um because like it didn't give us too much score. Even if we do a bit better on the first 50 cases, I think the real like the point the real big points that you could get were like in the other cases which were too big for this approach. Um so but but still I think this helped us to um get the idea for our final approach which is similar but it's there's no optimization anymore but still the idea is that instead of trying to optimize what we are executing in this one current time stamp we instead are trying to build a longer schedule. So I think for some reasons of like time limit balance and like um the quality kind of balance.

[00:37:51]So like we eventually did something like this. So we have some uh kind of okay some kind of a variable like I think it was like 50 or 70 time the ticks. So basically what we are doing is that we when we have the order of tasks in order of their like um resource uh needs right we have this order for each task we try to put it at the current time stamp if we can put it at the current time stamp we just put it there if we cannot we try to put it at time stamp t plus one if we cannot try to put at time stamp t plus2 and so on until like t + 50. Um and if we can find a place in the near future basically when we can execute this task we just put it there in the schedule.

[00:38:37]Um so basically the greedy approach is just discard the task if we cannot put it at time t but our approach um still puts it somewhere later. And I think why this is good is basically because if you have some task which is pretty bad for you because it maybe blocks some a lot of different good tasks but it maybe for some reason still fits in time stamp t you might not actually want to schedule it there. So the idea is that if there's a good task that you cannot do right now but you can do it very soon you should also account for it in your um simulation.

[00:39:17]So that was uh the main idea in the end that we um did. I think if you think about it deeply like if you think about the approach from uh Voyer Petra the first one presented today. Basically what they did is when they did this greedy approach if they had like 35 tasks in a row that they could not add to the current time stamp they just broke the for loop they just stopped trying any more tasks. I think it's similar in the approach because basically it's also preventing getting bad tasks from being executed at this current time right so I think it does it just in a different way so it just limits the tasks that you are taking in this current time stamp while our approach does not limit that but instead for tasks that you cannot do in this current time stamp you've scheduled them a bit later which will naturally limit some bad tasks from being scheduled right now so in a way It's similar in uh the intention but it's different in u implementation. And uh yeah, the last but not the least is uh of course the formulas for the greedy uh order are very important. And our um trademark formula was um this and uh this constant 1.594982 is very important. Uh 1.6 is maybe 1 million points uh worse.

[00:40:50]Um but um it was our um sub last submission with 26 seconds to go and it was a huge team effort. Basically each of us typed a few digits in this constant and uh that's how we got our best results. So that only proves that teamwork is crucial.

[00:41:15]>> Yeah, it's a magic. So any questions?

[00:41:21]Any question?

[00:41:24]No. No more question.

[00:41:26]Okay. Okay. Thank you. Thank you.

[00:41:34]>> Okay. Uh let's invite the next team is uh I think the next team is uh bad at DS.

[00:41:48]better at DS.

[00:41:53]Welcome Hey guys. Um, I'm going to share our code with you guys. And, um, uh, honestly, I think we didn't do much smarter things like the previous groups. And um we didn't identify the quadratic term in the uh schedule of the tasks and we didn't do spark things on GPU scheduling and also like we are using completely brute force on implementing the baselines. So uh but I think the non-trivial thing we have done is at here. So uh basically uh we have a great infrastructure on testing the hyperparameters and and integrating into our solutions. So uh we have a very small latency on trying each hyperparameter and improving the results. So uh we even build a local test system to like like estimating our scores uh based on the like pay previous performance or something. So uh so it enables us to try like 10 or 20 I think it's around 20 hyperparameters and for each task we select one that works the best and uh so we have two hyperparameters uh no I think it's three I think yeah so the first two is uh is how we schedule the tasks so you can see uh We have very bad code here.

[00:43:59]So don't run. So ST means uh yeah what S? Oh. Oh yeah. ST means L in and len means L out and the TT means uh the current waiting time. So like uh this task had already wait for TTX time.

[00:44:19]So like if uh C2 is greater than zero.

[00:44:23]So we will mostly prioritize those who wait the most. Uh and one of the smart things we identify is some task we the best hyperparameter is requires C1 to be less than zero. So it's very imp uh so very uh like uh like very uh not not very reasonable but uh it's uh practically is we can see yeah we can see here like some of the C1 is less than zero. So it turns out to work very well on some large task. uh I think you guys have already know the the largest task is uh task number 68 I think and uh the best C1 works for this is uh minus0.4 four.

[00:45:16]Yeah. Another thing is uh another thing is here. So, uh what we done here is uh we identifi we we noticed that some like uh some bad tasks that cost a lot uh um a lot of time cames very first and some easy task come came afterwards. So if you directly schedule the long tasks without receiving the short task it will cost a lot of time cause a lot of latency. So basically we what we done is to wait like if a task came in we first wait until the the next tick and uh two adjacent ticks is uh like 50 uh uh 50 time steps I think uh it's by default uh which means that if a task came at time step number two it will wait until time step number 50 until it's uh be scheduled and then there are lots of task and We can do like better optimization on this. Yeah. So that's all.

[00:46:22]>> Okay. Anyone has question to him? Okay.

[00:46:33]>> Hi. Uh thank you for your solution. Uh can can I ask like why is a TT term in the loss function? Because like uh like in the actual scoring function, right, it's like a sum over D.

[00:46:42]>> Yeah. uh like maybe if it's like sum over d square like the loss like this tt term will make sense to like but here like I don't think we care if like we swap different task right so yeah I was wondering about the t term yeah >> uh okay sure uh yeah it actually uh turns out the C2 is the last thing we add onto it and you can see uh in this in the data uh like C2 is rarely to be greater than zero so I think you are probably right But it turns out that it helps a little. So it may helps from the like 360 to 3601. So we just did it.

[00:47:22]>> Okay. Thank you.

[00:47:22]>> Yeah. So it's just experimentally.

[00:47:26]>> Any other question?

[00:47:32]>> How did youidentify?

[00:47:36]>> Oh yeah. So uh for each hyperparameter we submit once and get the results and copy it to local and for each task case we calculate the maximum.

[00:47:49]>> Yeah.

[00:47:50]>> Did you identify what?

[00:47:55]>> Oh yeah sure. Uh yeah for the uh first 40 task uh tasks uh I think we have um like k equals to four. Yeah and for 41 to 70 we have k equals to one.

[00:48:12]Uh yeah and the the number of b just varies. So uh there's no like clear message in it I think. uh but but but we what we did is what we did on the hash function I think is quite different because uh yeah we we are not hashing on NK and B we hash on the first task that cames in so it also have no cost but it's really helpful that separates 100 task in one shot Yeah.

[00:48:51]Okay. Any other question?

[00:48:55]Okay. Thank you.

[00:49:00]Uh let's invite the next team. The next team is uh Polish Mafia.

[00:49:07]Polish mafia. Welcome.

[00:49:21]Okay. So um okay so first it's I guess nobody mentioned it but uh I like the problem for being very nonobvious.

[00:49:43]So for example in the statement you were we were given the scoring function which consisted of like three summons and the first easy but none of nonobvious things is to ignore two of them.

[00:49:57]Uh and uh when we get to be being focused only on the uh on the sum of waiting times, uh we had a sorting function similar to most like we had uh sort by something uh similar to area with possibly a few variations about it.

[00:50:22]uh and we had a we also had a sorting function for the GPUs. So the problem was to for each for each uh for each job and each GPU to check whether we can fit it in in it and to also calculate how much space will be left uh because we want to use it in the sort uh and we were actually able to to code the data structure for that unfortunately because we [snorts] didn't get to the crucial optimization.

[00:50:57]Uh so we had to find the crucial optimization uh about breaking after like 20 jobs or something. Uh so we had to fight for points otherwise. So the main idea was to try many different uh uh many different uh scoring functions for the order of uh of the jobs.

[00:51:21]uh and uh we obviously would wanted to use this is the best of them on uh each each test case uh but it's untrivial because unlike in any other optimization competition the tests are closed and we don't know anything about them so I heard a few teams use the written codes which is I love this idea but we didn't didn't think about it so our idea was to allocate as many megabytes of memory as the hash of the test which also worked well. Uh and then based on the on the detected test we can apply the strategy of our choice.

[00:52:05]Yeah. Uh we also as as Gennady mentioned found teamwork very useful. uh in particular one of the teammates uh was producing one of those functions every half an hour or something and that was his all input into the [laughter] into the into solving of this problem. Uh we had some nice ideas like we at the beginning we thought that maybe it would make sense to once every now and then uh run the simulation on the historical data like if you wouldn't be able to get to know the test and we would like to choose the best strategy maybe after like 10% of the time it would make sense to check which strategy would be the best so far but as we get the uh the harshest of the of the test it's it didn't matter. Anyway, uh wait, I had the notes. Let me check if I have something else to add.

[00:53:06]Uh I guess one extra uh hint about writing data structures because we had like it's pretty simple. We didn't go for segment tree. We uh did something binary search based. So it's it can be done actually. Uh uh and a nice hint is to use the scoring to use the judge because we don't have local test to uh verify uh to have two codes that would that should have identical results on every test but one of them should be faster.

[00:53:46]So not not uh to not merge uh uh multiple changes but to check data structures separately and verify if the results didn't change and I guess that's it for us.

[00:54:04]Okay. Any question to him?

[00:54:07]Uh I have questions that you for example the 353 line you use the test to uh identify the the tech case right?

[00:54:20]>> Yeah.

[00:54:20]>> Uh uh but how do you know that the test the test is the the hashy or >> yeah I mentioned that a few previous teams use the return code to return the hash of the of the test but we didn't we didn't come up with that. So we calculated a hash like model 100 or something like that and that's how many megabytes of memory we allocated. I think we have it somewhere uh somewhere give me a second.

[00:54:54]Oh yeah, that's unfortunately in Polish, but it's supposed to uh to allocate as much memory as the hash of the test and the judging system were reporting that. Yes, >> my teammate brought it, but I'm I'm so I'm so pleased that you know it.

[00:55:22]Any other questions?

[00:55:28]>> Okay, any question?

[00:55:31]Oh, no. Okay, thank you.

[00:55:34]Okay, let's invite the next team. The next team is we press with mod in the northeast.

[00:56:04]Uh >> um yeah. So we use uh similar ideas as uh some of the pre previous teams like we um we have a function on the like we have we have a function like calculating some value of the of each task that we want to give a priority of the tasks and the function is like um um combination depending on test cases. Um but the head of idea is that we gave maybe a quadratic um function on the L out the duration and uh like a linear I mean uh yeah so uh so it's so so it looks like this and um and also a slight difference with uh compared with previous team is that we also gave some um penalty on the arrival time. That's this is the the last term is the arrival time. But this is small because we uh we give a like higher priority on the uh on the size of the task, right? like we we want to uh so we want to uh perform the light uh lighter task earlier and then um and then um so we so so then we we use this greedy and uh each time we check uh if some task uh in the queue can be performed by some GPU and um and here we for for one task if it can be performed by multiple GP GPUs. We also give score on the G GPUs. Uh the score looks uh the score is here. So um we gave the we assign the the task to the GPU with the the load um the proper load that that is closer to the like the closer to the size of this task. So, so this is the the the score is um so so this is the load of this uh GPU.

[00:58:26]The load the load is computed using um the capacity remaining uh divided by the the remaining number of um task it can perform. So say if there if there's only one slot left then uh it is just the remaining uh workload the remaining memory and um yeah so you can see like in the end we we just do we want to we also we also want to combine uh several functions but in the end we don't have enough time that we we just do it uh like very um I mean like lightly like divided by K and some uh large large test case and yeah that's our solution uh okay any question to him any question okay no so thank you very Okay, let's invite next team. The next team is a gun.

[00:59:50]Welcome Click click.

[01:00:36]What?

[01:00:41][snorts] Uh well, I'll explain step by step.

[01:00:48]Actually, I don't know the problem as a whole. Uh so here's a data structure.

[01:00:57]Uh by the way quick language lesson is data structure is pronounced.

[01:01:03]It means data structure in Korea. Uh this means task in Polish language. But I always pretend that I know Polish. But but but I wouldn't try to pronounce it.

[01:01:16]I I'll not do that. I know I'll fail. So I'll not do that and stuff and stuff but the bas basically it's simple uh so so basically what we're trying to do here is to maintain a data structure which supports adding a task and like which supports whether we can add a task or just really add a task if given that it is safe to add a task uh the time complexity here is O O B and the memory probably likewise so it's quite efficient is not the best. I guess I guess you can do it log time, but why?

[01:01:53]Uh and also also something that is kind of important here is that uh this is a pair. So you you see that we return a pair. Uh why why why there's another Polish language? I don't know. Uh but whatever. Uh uh so there's a pair. Uh so so this means we can add it. We we can add this task. And the next one the remain is kind of a uh so so so for every time so for every time frame uh if we add a task then this is the minimum of the remaining uh GPU memory size or whatever. This is the minimum of the GPU memory size over the length L in time L in plus L out minus one. So we compute that in the data structure and we will use it accordingly. Uh basically huh something amazing happening. Uh huh. Okay this is getting long. Uh so so okay uh we need to know the task uh and we do know the task but the problem is uh I don't know uh the the way we interacted with the judging system. Uh so so okay why why do we need to know the task? We had some strategy something works on some task and the other things on work on other important tests. So we want to take the point wise like like test wise maximum.

[01:03:23]So basically that's it. Uh and and so how do we know each test? Uh basically uh you can have four answers right accepted wrong answer time limit exited runtime error. So so well you can you can do two things. uh this gives runtime error this gives time limit exited right uh and I guess this gives you a wrong answer so so and these are based on the hash of the determined values of the input deter like the the non-interaction part of the input and so uh with with this so with six submission and a good parser which we wrote separately but you don't have it here because it's in local so we we wrote part parser and from there we can infer the test number and from there we have certain strategies and we just actually compute the score which is also from the parser and we'll set our our strategy accordingly. So what is the strate? So so so the strategy the way strategy differs is the sorting order.

[01:04:34]So given the sorting order how do you perform it? Uh uh yeah yeah yeah given the story mode how do you perform it actually I'm not sure I think my teammates will tell you about it oh uh the rule is I think mostly similar to other teams it's l in time mo one is which is coefficient plus mo uh l out time mo two which is also coefficient and also there's one another strategy that is about the area at the the task fields. So there's uh one strategy for just linear and one strategy for quadratic and there's about seven strategies and we just did points maximum and yeah and yeah we got the point maximum and we got the score. Is there something?

[01:05:38]Yeah, it's just greedily fill the text.

[01:05:43]That's it.

[01:05:46]Okay. Any question to then?

[01:05:50]Any question?

[01:05:53]Okay.

[01:05:58]So, I have a questions about uh your passer. So uh from your previous experience uh to join to to attend other UCPC or other ICPC challenge session. So is it a usual way to use a passer to generate uh this large volume of uh kind of parameters or magic data. So so uh because our challenge problem is from a real uh business scenario. So we simulate a online inference system. So with randomly arriving large volumes of requests. So uh so I'm I'm trying to understand whether it's a usual way to use this uh kind of technique to uh resolve a uh UCPC challenge problem.

[01:06:49]>> I don't think usually we can see the each score for each test case. So I think this is one of the specific case but since there is an obvious advantage to separate each task for this kind of uh submission so I think we just take that strategy for this problem especially okay so the reason I think is because of the distribution of the requests is just unidentifiable so you don't know any uh statistics of of this large volume of requests. So you use the parser try to generate the the parameters and the hash number. Am I right?

[01:07:35]>> Uh yeah uh uh yeah uh well I guess my take is that uh well first of all I I don't do a lot of challenge. I don't think also does a lot of challenge either. So so whether this is a normal thing or not uh we are not in the capacity of answering it. Uh we don't know we're programming contest participant so we have no idea. Uh the second thing uh whether this is normal I guess no and I think the challenge problems we have participated usually just gives you the test data. So this I mean I mean taking the maximum of the strategy should be quite obvious in most of the like at least the at least the subs that we did like like for example hash code I think I think there it is just something we can do but here we cannot do it do it and if we do it it was adventure so we should do it. Yeah.

[01:08:30]Okay. Okay. Thank you. Any else question?

[01:08:37]>> Uhhuh.

[01:08:39]>> Uh, what? Wait, wait. Could you >> uh h good question. Uh, >> how do you pronounce?

[01:08:48]>> Uh, well, you gave me a hint. Uh, scoopo.

[01:08:52]Well, I I would say like scopu.

[01:08:54]Something like that. I think scopu.

[01:08:57]Wait.

[01:08:58]Okay. Okay. Okay. This is why I don't attempt to pronounce it. I actually did, but like I at some point I realized the all the pronunciation I knew was all wrong and stuff. Yeah. [laughter] Yeah.

[01:09:13]Yeah. Well, I mean I sold a lot of POI so I guess. Yeah. [laughter] Yeah.

[01:09:21]Okay. Any other question?

[01:09:24]Uh I I thought you had generated some so so many rand uh magic number during uh during the call. Uh is it totally random or random by some strategy?

[01:09:36]The number the list of the numbers you have seen is not magic. These are the result of the these are the verdict of the submission that we had. We had a parser to pro to translate it as a score score list. So we don't have a magic function. The magic function we have is just this just these five steps are the magic functions we have. There are some sort of trade-offs here but well yeah this is all the magic constants we have I think. Yeah and these are just like fractions. Yeah.

[01:10:20]Okay. Uh another question is just now you have say when we arrange uh a task into a sophistic uh GPU you say the first uh time frame is the minimal uh memory usage uh uh what do you mean the minimum GPU memory usage is for for this tax or for the whole GPU? Oh uh that means if I assign this text to this GPU >> then the uh there's some time frame that have minimum uh memory remains so it's like tight so we want to make GPU tight so >> oh >> yeah the the last the rest uh GPU memory >> yes that's the least remaining in memory.

[01:11:15]>> Okay, >> for that >> thank you.

[01:11:18]>> Okay, thank you RBU. Thank you. Please take a seat. And there there is all the teams we had invited. So if anyone any other teams want to be a volunteer to share your code, share your idea, please raise your hand.

[01:11:36]Okay, thank you. uh >> you can introduce yourself first. Uh >> okay. So I'm from uh team homo and we uh if you're remember that we did pretty well in the first hour and then failed badly. So that's why we didn't [gasps] like want to give a speech. But I found something. we only only one our team uh did so let me explain it so it's like so during the testing we found that the uh at the moment we receive all the end requests uh 90% of the requests are not assigned so which means 90% of the problem can be solved in non-interactive way so I just like split the problem So in the interactive phase I did uh similar thing to other teams and the in the and after reading all n requests I oh sorry I I solved it in a different way uh which is in a batch function uh which means uh we have all the remaining requests and solve it uh solve it assuming there's no further requests and the advantage of this strategy is that you can try several salting functions which means so I heard some some teams are trying to uh like guess the hash of the [gasps] like test case and switch switch several sorting functions but in this strategy in our strategy you don't have to do that because uh you can since the problem is not interactive you can like try just try to solve it with several sorting functions and just take the best one and that's what we did and yeah so and the inside of the batch function is kind of similar to other teams we just use sever sorting sorting and assigning sorting p request and assigning it gridly and the sorting function is uh kind of yeah like this so just a linear combination of out and in time And what we change by it is the weight of the these two out and in values. Then I think yeah these are the these are the cofficients of these two variables. So I run several batches with those parameters and take the best one. Um yeah I that's all what we did. So thank you very much.

[01:14:30]Okay. Any question to him? Okay.

[01:14:36]>> Uh, exactly. Maybe >> this 90% that you mentioned was it happening in this 20 important test with K equal to or in the >> uh so sorry I I hear you [laughter] >> this 90% thing that you mentioned this static problem was this occurring in those 20 important tests with K equal to one or in the other tests >> I actually we didn't like [laughter] we didn't know the value of K we didn't try to guess it >> I I meant from 51 to 70 >> uh no I mean uh I if I remember correctly I I wrote I submitted a solution there's assertion that um when finished reading n tasks uh if the number of like finished task is less than like sign of 10% of the task like assert pass assert and otherwise like abort or something and if I remember correctly almost all the test pass so that's why I thought that like switching to static problem would be better and actually it worked so but u I could be wrong yeah but some some tests failed so yeah but I'm not sure which test was that >> okay any other question.

[01:16:08]Uh I have question that I had see uh inside the code you have a command that uh there CF uh >> CF problem.

[01:16:20]>> Yeah.

[01:16:20]>> Uh I have saw a comment that say indicate CF is a template or >> I think it's a template.

[01:16:30]>> Oh, use a template. Okay. Okay.

[01:16:34]Any other question?

[01:16:38]Okay, thank you. Thank you very much.

[01:16:41]Thank you for your sharing.

[01:16:44]Any other volunteer here?

[01:16:50]Any other volunteer?

[01:16:53]Oh, so Oh, it is the end of the ros. So, uh section. Uh we can take a a break step. Pay attention. We will uh the close ceremony the award ceremony will begins uh in 1515. So pay attention to back here before 1515. Thank you. Thank you very much. See you later.

[01:17:22]>> Yeah.

[01:17:33]Yes.

[01:18:03]>> [music] >> Heat. Heat.

[01:18:11][music] >> [music] >> Heat. Heat.

[01:18:34][music] >> [music] >> Heat. Heat. [music] [music] Heat.

[01:19:08][music] [music] [music] Heat.

[01:19:27][music] >> [music] [music] >> Yeah, I've started my computer programming journey uh when I was a junior high and my first aim was to uh win gold in II. Uh then when I entered university, my goal was to win gold in ICBC.

[01:20:08]>> I think I've started competitive programming at around like 2011. I won ICBC world finals in 2018 [music] and 2019.

[01:20:24]Scratch [music] and I started doing them actually quite a while ago [music] which is 15 years already. I'm the youngest. I'm doing comeic programming for 11 years. At some point [music] you come across uh like a branch of math which is programming and you decide that it's it's interesting, it's nice, you try it and maybe you discover that you're [music] good at it.

[01:20:57]I've been doing competitive programming for quite a while now um since I was [music] uh seven or 8 years old. I started uh mostly because my parents are programmers and they just [music] felt like I mean I was probably good at math but I didn't wasn't doing math Olympics of course but uh they decided [music] that like I can try and like see what what goes. I started competitive programming in my third grade of the [music] high school. I study statistics at my university and I have interest in the in finance. So in my future I I will study about finance more than programming but I I like to do competitive programming because uh puzzle and mathematical things of the this is very fun.

[01:21:52]>> [music] >> I think ICPC teaches you how to uh solve problems in general like problem solving skills and also how to do things fast even if for example you're doing coding interview or just doing work at work it actually I think uh indirectly helps you and I [music] think I observed some cases where I think people could have benefit from having some uh sort of background like I Yeah. And I I do think that [music] it competitive programing experience helps you to like go to faster to like create some like starting point to like create some code quickly [music] and to get it working. Also, it helps you to be like more careful with like some corner [music] cases because you in competitive programming, you want your code to like always work on all test cases.

[01:22:46]I just enjoy problems. Of course, I enjoy winning, but uh even if I can't win, uh I still can enjoy computer programming. So, I'll keep I'm involved in this community. One uh definitely important thing is that uh competitive programming problems are challenging and they are like being pro progressively better at them. I think uh performing under pressure is another factor that can become uh important in life at various points and I think it's generally competitive programming experience [music] is really useful for high frequency trading because like you want to test a lot of ideas and you want to do it quickly and that's precisely what is like very good what competitive programming trains you to do.

[01:23:48]pure job of solving interesting problems and [music] work in the team. So now it's an outside event. I'm really happy to be here because usually we even in [music] a team we participate in contest remotely and it's not the same experience [music] but uh anyway I think a lot of engineering skills indeed like uh there's a [music] lot to gain and um especially like if you are looking for like different ways to do it like I think you can learn a lot from other people and uh for example often when you do competitions you [music] can learn the approaches of other people or like how they handle their like code or like ideas and that's uh very valuable.

[01:24:31]>> I will just stay close to just theoretical research. I'm [music] now working on cotling programming language compiler.

[01:24:41]I'm quite happy with what I'm doing and don't have any [music] plans for big changes.

[01:24:46]>> I did a research math degree after just right after my ICBC uh last event. So um that's possibility to return to I didn't get a PhD.

[01:24:59][music] >> [music] >> Well, I work in physics. I'm an experimental [music] physicist.

[01:25:19]>> I am a bachelor student and right now I really want [music] to keep studying and pursue a master's degree and maybe something even further.

[01:25:31][music] >> [music] >> For me personally, it would be cool to be on on the cutting edge [music] of technology.

[01:25:58][music] >> [music] [music] [music] >> Heat. Heat.

[01:26:26][music] Heat. Heat.

[01:26:36][music] [music] [music] Heat. Heat.

[01:27:01][music] [music] Heat.

[01:27:25][music] Heat.

[01:27:37][music] Heat.

[01:27:50][music] Heat.

[01:28:01][music] >> [music] >> You saw how long [music] you got here.

[01:28:39]>> [music] [music] >> Hey.