Hi, my name is Kirill Simonov. I am a Competitive programmer Coach at Saint Petersburg State University and I'm excited to welcome you in this course. First of all, a couple of thoughts about why learning competitive programming is good for you. Competitive programmers write reliable and efficient programs. And so, it might help you in getting a job or if you're writing in a job which handles large amount of data. Competitive programmers also are very motivated to learn and practice different algorithms. And if you didn't get enough time to do it before, with competitive programming, you'll do it easier. In competitions there is also a very limited time like two hours on a lot of problems. And so, it will gain you time management skills. So you could do things efficiently under stress in limited time. And it all algorithms, efficient programs and managing time is things that could be very useful not just in life, but also for example on job interviews, where you get asked algorithm questions and need to answer rather quickly. Another good side in competitive programming is that its community consists of very motivated and smart people, and so it's a lot of pleasure being in the community and communicating with them. And also, solving problems is just fun and captivating by itself. So competitive programming is both a mind sport like chess and a way to gain useful knowledge for your everyday life and job. In this course, we'll cover basic skills and tricks which may be needed for a competitive programmer and also some common algorithmic ideas. So you could jump right at competitions when you've finished this course. In the first week, we'll introduce what competitions and problems on them are, what are their specifics, and we'll also talk a bit more about how to test your programs. On the second week, we'll talk in detail how to write code that it's correct. We'll also talk about the idea of brute force algorithms, which could solve basically any problem, only it's always slow. It's usually slower than needed, but sometimes it's the right solution. And we'll also talk about time complexity, meaning then, how you could estimate, view your program pass or not on the said meters. On the third week, we'll discuss issues that could be with handling numbers in programs and in competitions. This is just really good to show up. And, we'll also discuss how to, well, if you get stuck on some program, when you have an implementation and don't know what to do about it, because it doesn't work. We'll talk about a few tips about how to get out of the situation. On week four, we'll talk about an idea of greedy algorithms, which is first of all a common type of algorithms. And there are also a lot of pitfalls. Correct solution and incorrect solution here are separated by a very close gap. So here it's important to get the right idea and prove it, or see otherwise that it's correct. We'll also talk about specifics of different languages. So which one for example you should choose for use in BETA programmings, in BETA programming. And we'll also cover a useful latest structure called a Segment Tree. On weeks five and six, we'll talk about dynamic programming. It's a very common idea, many algorithms could be reduced to it somehow. We'll cover some common problems for example edit distance, which is, what you should do to get one string from the other by insertion, deletions and swapping characters. Knapsack problem and other problems which are classic and basic. And along the course, you'll horn your skills, get at lectures by solving programming assignments, which are very similar to actual competition problems. So that's what we'll be doing in the course. In the next video, we'll start with specifics of competitive programming.