92 |
98 |
93 | {features.map((props, idx) => (
94 |
97 | 13 | (i) [Hackerearth article on BFS](https://www.hackerearth.com/practice/algorithms/graphs/breadth-first-search/tutorial/)
14 | (ii) [CP-Algorithms article on BFS and its applications](https://cp-algorithms.com/graph/breadth-first-search.html) 15 | 16 | 3. Read the following articles for Depth First Search (DFS) :
17 | (i) [Hackerearth article on DFS](https://www.hackerearth.com/practice/algorithms/graphs/depth-first-search/tutorial/)
18 | (ii) [CP-Algorithms article on DFS and its applications](https://cp-algorithms.com/graph/depth-first-search.html)
19 | (iii) [DFS using standard color coding and calculating discovery and finish times](https://www.gatevidyalay.com/depth-first-search-dfs-algorithm/) 20 | 21 | 4. For better understanding of DFS and BFS, [try DFS and BFS visualisation on VisuAlgo](https://visualgo.net/en/dfsbfs) 22 | 23 | ## Topological Sort 24 | 25 | 1. Go through [the hackerearth article](https://www.hackerearth.com/practice/algorithms/graphs/topological-sort/tutorial/) or [CP-Algorithms article](https://cp-algorithms.com/graph/topological-sort.html) for topological sort 26 | 27 | ## Strongly Connected Components (SCC) 28 | 29 | 1. Go through [this article](https://www.hackerearth.com/practice/algorithms/graphs/strongly-connected-components/tutorial/) for Kosaraju's algorithm to find SCC 30 | 2. For C++ implementation of the algorithm to find SCC, refer [this article](https://cp-algorithms.com/graph/strongly-connected-components.html) 31 | 32 | ## Disjoint Set Union (DSU) 33 | 34 | 1. Go through [this article](https://www.hackerearth.com/practice/notes/disjoint-set-union-union-find/) for DSU and its implementation. 35 | 2. For more applications of DSU, refer [this article](https://cp-algorithms.com/data_structures/disjoint_set_union.html) 36 | 37 | ## Shortest Path Algorithms 38 | 39 | - Read [this article](https://www.hackerearth.com/practice/algorithms/graphs/shortest-path-algorithms/tutorial/) for the implementation of the standard shortest path algorithms - Dijkstra, Bellman Ford and Floyd Warshall.
40 | 41 | :::tip 42 | Do note the time and space complexities and the limitations of each method. 43 | ::: 44 | 45 | ## Minimum Spanning Tree (MST) 46 | 47 | - Go through [this article](https://www.hackerearth.com/practice/algorithms/graphs/minimum-spanning-tree/tutorial/) for both Kruskal's and Prim's algorithm. 48 | 49 | ## Session slides 50 | 51 | - Slides for basics of graph, graph representation and BFS, are available [here](https://drive.google.com/file/d/18WOB_HSEK2nBZFlM0fsL46g_dRlbEFBa/view) 52 | 53 | - Slides for topological sort and SCC are available [here](https://drive.google.com/file/d/1rk-IvUknpE4RCj8J6S6iL09Y8egV58gA/view?usp=sharing) 54 | 55 | - Slides for shortest-path algo, graph modeling and MST are available [here](https://drive.google.com/file/d/1BuhFA3AqVv7tyH4RG8cxlIhyReTkOPtW/view?usp=sharing) 56 | 57 | ## Additional Resource 58 | 59 | - Sometimes, in problems, it is required to construct a state graph out of the given graphs and then, apply any standard algorithm, to solve the problem. This technique is known as **Graph Modelling**. Refer [this blog](https://codeforces.com/blog/entry/45897) for more about it and some solved example problems. 60 | -------------------------------------------------------------------------------- /src/pages/index.js: -------------------------------------------------------------------------------- 1 | import React from 'react'; 2 | import clsx from 'clsx'; 3 | import Layout from '@theme/Layout'; 4 | import Link from '@docusaurus/Link'; 5 | import useDocusaurusContext from '@docusaurus/useDocusaurusContext'; 6 | import useBaseUrl from '@docusaurus/useBaseUrl'; 7 | import styles from './styles.module.css'; 8 | 9 | const features = [ 10 | { 11 | title: 'Understanding algorithms', 12 | imageUrl: 'img/undraw_solution_mindset.svg', 13 | description: ( 14 | <> 15 | Understand all the algorithms and data structures well. You should be 16 | able to figure out when to use a particular data structure or algorithm. 17 | It's rightly said that "You don't have to be great to start, but you 18 | have to start to be great." 19 | 20 | ), 21 | }, 22 | { 23 | title: 'Practice', 24 | imageUrl: 'img/undraw_Process.svg', 25 | description: ( 26 | <> 27 | Practice the set of questions given to you, after each session. Make 28 | sure, you try them, by yourself. You should look at the editorial, 29 | hints, etc. only when you have given enough time to a question and 30 | still, you are not able to figure out the correct approach. Never say "I 31 | can't" because you can and you will, it takes practice to become 32 | perfect. 33 | 34 | ), 35 | }, 36 | { 37 | title: 'Regular contests', 38 | imageUrl: 'img/undraw_exams.svg', 39 | description: ( 40 | <> 41 | As, giving timed contests, helps to handle problems under pressure and 42 | boosts your time management skills. Give the contests on various online 43 | judges, regularly, as instructed here. Try to upsolve 1 44 | or 2 problems after every contest. 45 | 46 | ), 47 | }, 48 | ]; 49 | 50 | function Feature({imageUrl, title, description}) { 51 | const imgUrl = useBaseUrl(imageUrl); 52 | return ( 53 |
54 | {imgUrl && (
55 |
62 | );
63 | }
64 |
65 | function Home() {
66 | const context = useDocusaurusContext();
67 | const {siteConfig = {}} = context;
68 | return (
69 |
56 | 
57 |
58 | )}
59 |
57 | {title}
60 |{description}
61 |
74 |
87 | {siteConfig.title}
75 |{siteConfig.tagline}
76 |
77 |
83 | Get Started
84 |
85 |
86 | 39 | Caution: endl slows down output, so it is better to use ‘\n’. 40 | - To input a line i.e. to input a string with spaces we use gets in C while getline in C++. 41 | - All the functions like cin, cout etc. are defined in a standard namespace. So, instead of directly using it we usually add a namespace to avoid writing std every time. You do not need to understand much about namespace. Just remember to add this statement at the top in your C++ code : 42 | ```cpp 43 | using namespace std; 44 | ``` 45 | 46 | ## Multiline inputs 47 | 48 | Suppose you need to take the input in the following format : 49 | 50 | 1. The first line contains an integer, a floating point number and a character. 51 | 2. The second line contains a sentence, with spaces between the words. 52 | 53 | Now, try running these codes. 54 | 55 | - In C, the code for this would be : 56 | ```cpp 57 | #include
```#include
.... | ```#include
scanf(“%d”,&a);
printf(“%d,a); | int a;
cin >> a;
cout << a; | Use of cin, cout in place of scanf and printf 106 | int a; float b; char c;
scanf(“%d %f %c”,&a,&b,&c);
printf(“%d %f %c”,a,b,c); | int a; float b; char c;
cin >> a >> b >> c;
cout << a << b << c; | Multiple input output at the same time 107 | printf(“%d\n”,a); | cout << a << endl; | To print some variable a followed by a newline character 108 | char a[100];
scanf(“%s”,a); | char a[100];
cin >> a; | To input a string without spaces 109 | char a[100];
gets(a); | string a;
getline(cin,a); | To input a line
Note - If you make a character array, you will have to use gets in cpp as well. 110 | -------------------------------------------------------------------------------- /static/img/logo.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docusaurus.config.js: -------------------------------------------------------------------------------- 1 | const math = require('remark-math') 2 | const katex = require('rehype-katex') 3 | 4 | module.exports = { 5 | plugins: [ 6 | [ 7 | '@docusaurus/plugin-google-gtag', 8 | { 9 | id: 'plugin-google-gtag-1', 10 | }, 11 | ], 12 | [ 13 | '@docusaurus/plugin-google-analytics', 14 | { 15 | id: 'plugin-google-analytics-2', 16 | }, 17 | ], 18 | ], 19 | title: 'Competitive Programming', 20 | tagline: 'A roadmap by Cyberlabs', 21 | url: 'https://cp.cyberlabs.club', 22 | baseUrl: '/', 23 | organizationName: 'Cyber-Labs', 24 | projectName: 'cp-roadmap', 25 | favicon: 'img/cl_logo.png', 26 | onBrokenLinks: 'throw', 27 | stylesheets: [ 28 | { 29 | href: 'https://cdn.jsdelivr.net/npm/katex@0.12.0/dist/katex.min.css', 30 | type: 'text/css', 31 | integrity: 32 | 'sha384-AfEj0r4/OFrOo5t7NnNe46zW/tFgW6x/bCJG8FqQCEo3+Aro6EYUG4+cU+KJWu/X', 33 | crossorigin: 'anonymous', 34 | }, 35 | ], 36 | themeConfig: { 37 | navbar: { 38 | title: 'Competitive Programming', 39 | logo: { 40 | alt: 'CL', 41 | src: 'img/cl_logo.png', 42 | }, 43 | items: [ 44 | { 45 | to: 'docs/roadmap/', 46 | activeBasePath: 'docs/roadmap', 47 | label: 'Roadmap', 48 | position: 'left', 49 | }, 50 | { 51 | to: 'docs/contests/2020/number-theory-and-bs', 52 | activeBasePath: 'docs/contests', 53 | label: 'Contests', 54 | position: 'left', 55 | }, 56 | { 57 | to: 'docs/tools', 58 | activeBasePath: 'docs/tools', 59 | label: 'Tools', 60 | position: 'left', 61 | }, 62 | { to: 'blog', label: 'Blog', position: 'left' }, 63 | { 64 | href: 'https://github.com/Cyber-Labs/cp-roadmap', 65 | label: 'GitHub', 66 | position: 'right', 67 | classname: 'header-github-link', 68 | }, 69 | ], 70 | }, 71 | algolia: { 72 | apiKey: 'efa073bae52f1aee1d50007d26ee7f9b', 73 | indexName: 'dev_CP', 74 | appId: 'K602RCS7E1', 75 | // searchParameters: {}, // Optional (if provided by Algolia) 76 | }, 77 | footer: { 78 | style: 'dark', 79 | links: [ 80 | { 81 | title: 'Roadmap', 82 | items: [ 83 | { 84 | label: 'Basics', 85 | to: 'docs/roadmap', 86 | }, 87 | { 88 | label: 'STL', 89 | to: 'docs/roadmap/stl/stl-tutorials', 90 | }, 91 | { 92 | label: 'Number Theory', 93 | to: 'docs/roadmap/number-theory/number-theory-tutorials', 94 | }, 95 | { 96 | label: 'Binary Search', 97 | to: 'docs/roadmap/binary-search/binary-search-tutorials', 98 | }, 99 | { 100 | label: 'Graph Theory', 101 | to: 'docs/roadmap/graphs/graph-tutorials', 102 | }, 103 | { 104 | label: 'Programming Techniques', 105 | to: 'docs/roadmap/programming-techniques/greedy-tutorials', 106 | } 107 | ], 108 | }, 109 | { 110 | title: 'Important Tools', 111 | items: [ 112 | { 113 | label: 'Coding Schedule', 114 | href: 'https://codingschedule.gitlab.io/', 115 | }, 116 | { 117 | label: 'OEIS', 118 | href: 'https://oeis.org/', 119 | }, 120 | { 121 | label: 'CP Editor', 122 | href: 'https://cpeditor.org/', 123 | }, 124 | { 125 | label: 'Diff Checker', 126 | href: 'https://www.diffchecker.com/', 127 | }, 128 | { 129 | label: 'CSAcademy online IDE', 130 | href: 'https://csacademy.com/workspace/', 131 | }, 132 | { 133 | label: 'VisuAlgo', 134 | href: 'https://visualgo.net/en', 135 | }, 136 | { 137 | label: 'Algorithm Visualizer', 138 | href: 'https://algorithm-visualizer.org/', 139 | }, 140 | ], 141 | }, 142 | { 143 | title: 'More', 144 | items: [ 145 | { 146 | label: 'Blog', 147 | to: 'blog', 148 | }, 149 | { 150 | label: 'Contests', 151 | to: 'docs/contests/2020/number-theory-and-bs', 152 | }, 153 | { 154 | label: 'GitHub', 155 | href: 'https://github.com/cyber-labs', 156 | }, 157 | ], 158 | }, 159 | ], 160 | copyright: `Copyright © ${new Date().getFullYear()} Cyber Labs. All Rights Reserved.`, 161 | }, 162 | googleAnalytics: { 163 | trackingID: 'UA-149721084-2', 164 | anonymizeIP: true, 165 | }, 166 | gtag: { 167 | trackingID: 'UA-149721084-2', 168 | anonymizeIP: true, 169 | }, 170 | }, 171 | presets: [ 172 | [ 173 | '@docusaurus/preset-classic', 174 | { 175 | docs: { 176 | sidebarPath: require.resolve('./sidebars.js'), 177 | // Please change this to your repo. 178 | editUrl: 'https://github.com/cyber-labs/cp-roadmap/edit/master/', 179 | routeBasePath: '/docs/', 180 | remarkPlugins: [math], 181 | rehypePlugins: [katex], 182 | }, 183 | blog: { 184 | showReadingTime: true, 185 | // Please change this to your repo. 186 | editUrl: 'https://github.com/cyber-labs/cp-roadmap/edit/master/', 187 | }, 188 | theme: { 189 | customCss: require.resolve('./src/css/custom.css'), 190 | }, 191 | sitemap: { 192 | cacheTime: 600 * 1000, // 600 sec - cache purge period 193 | changefreq: 'weekly', 194 | priority: 0.5, 195 | trailingSlash: false, 196 | }, 197 | }, 198 | ], 199 | ], 200 | } 201 | -------------------------------------------------------------------------------- /static/img/undraw_solution_mindset.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /static/img/undraw_coding.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /static/img/undraw_Process.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/roadmap/stl/stl-editorials.mdx: -------------------------------------------------------------------------------- 1 | --- 2 | id: stl-editorials 3 | title: Editorials to STL practice problems 4 | sidebar_label: Editorials to STL practice problems 5 | description: Editorials to STL practice problems by cyberlabs 6 | --- 7 | 8 | :::caution 9 | 10 | Don’t read the editorial, if you have not attempted or read the problem. It would hamper your thinking capability, if you do so. 11 | 12 | ::: 13 | 14 | ## Hackerrank 15 | 16 | 1. [Deque STL](https://www.hackerrank.com/challenges/deque-stl/problem) 17 | 18 |
Editorial
19 |
20 |
21 | You need to give a O(N) solution. You can see the approach using a deque or queue here :
22 | [See the Queue modification (method 1) here](https://cp-algorithms.com/data_structures/stack_queue_modification.html#toc-tgt-1)
23 |
24 |
Editorial
30 |31 | 32 | See above problem’s editorial , as it is almost the same question, with a slight modification. 33 | 34 |
35 |Editorial
40 |
41 |
42 | We can use a stack to solve such kinds of problems.
Let's define {, (, and [ as opening brackets and }, ), and ] as closing brackets.
Algorithm:
43 |
44 | - Whenever an opening bracket appears, we push it onto the stack.
45 | - If a closing bracket appears and if it matches the opening bracket at the top of the stack, it means that the brackets are balanced and we pop the opening bracket out of the stack and continue analyzing the string.
46 | - If the closing bracket doesn't match the opening bracket at the top of the stack (or the stack is empty at that stage), we can infer that the string is not balanced, and we print NO.
47 | - After processing the string completely and if the stack is empty, the string is balanced, and we print YES, else, we print NO
48 |
49 |
Editorial
57 |
58 |
59 | You can use a stack, to calculate the largest rectangle area in a histogram, in just O(N) time complexity.
60 | First , think of a naive or brute-force approach, to understand the efficient solution.
61 | For each bar, we can find the rectangle with the height of it and also containing it.
62 | To do this for a bar, let's say bar, we go to left from
and stop at the first bar which is smaller than the
bar. Say we have stopped at
position.
63 | Then, we move to the right of and stop at the bar which is smaller than
bar. Say we have stopped at
bar.
64 | So, the rectangle containing bar and of its height will have width from position
to
(exclusive). The width will be
65 | We can calculate the area of this rectangle for each bar and take the maximum. That will be our answer. But it has a time complexity of in the worst case, which may give TLE here.
66 | Now, to reduce the time complexity, we will use a stack here, in such a way that we maintain the heights of bars in the stack, in an increasing order. And also, we will push the index of bar to the stack, instead of height. Now, think of some approach, using this stack, by your own. Still if you didn’t get it, you can watch this video for explanation. Thus, we can easily solve this problem in time complexity.
67 |
68 |
Editorial
76 |
77 |
78 | **Pre-requisite** : Set / Map
79 | **Explanation** : Our task is here to check weather a sock of same type is already on the table or not, and note the no of socks on it and output maximum of all our readings of no socks.
80 | Here it is given that the index of sock is ≤100000 thus you can also make an zero array and each time check if it zero or not (i.e checking weather a socks is on table or not.)
81 | But if index very large or something else as string ,char etc then it better to use set here.
82 |
83 |
Editorial
88 |89 | 90 | [View here](https://codeforces.com/blog/entry/507) 91 | 92 |
93 |Editorial
98 |
99 |
100 | **Prerequisite** : STL queue, map
101 | **Explanation** :
102 |
103 | Consider a queue e for every application and also a queue Q for the notification bar.
104 |
105 | i. When an event of the first type happens, increase the number of unread notifications by 1 and push pair (i, x) to Q where i is the index of this event among events of the first type, and also push number i to queue e[x].
106 |
107 | ii. When a second type event happens, mark all numbers in queue e[x] as visited,clear this queue and decrease the number of unread notifications by the number of elements in this queue before clearing.
108 |
109 | iii. When a third type query happens, do the following -
110 |
111 | ```python
112 | while Q is not empty and Q.front().first<=t:
113 | i = Q.front().first
114 | x= Q.front().second
115 | Q.pop()
116 | if mark[i] is false:
117 | Mark[i] = true
118 | e[v].pop()
119 | ans = ans - 1
120 | ```
121 |
122 |
Editorial
128 |
129 |
130 | **Pre-requisite** : Vector / Map
131 | **Explanation** : Firstly let's count a number of different states that we can have in the game. Cards can be arranged in any one of n! ways. In every of this combination, we must separate first soldier's cards from the second one's. We can separate it in n + 1 places .
132 |
133 | So war has (n + 1)! states. If we'd do (n + 1)! "fights" and we have not finished the game yes, then we'll be sure that there is a state, that we passed at least twice. That means that we have a cycle, and game won't end. Otherwise , the game would end simply with one soldier having empty set.
134 | Since , n is very small one can use the above brute force method , so the time complexity will be O(n*(n+1)!). The other n is used by map to check the repetition of the states.
135 |
136 | One can use vectors to represent states of the soldiers. In every fight do as said in the problem and store the states . Also keep the count of no. of fights. If any of the state gets repeated , then the game would end in an infinite loop, hence print -1 and end the game. If at any instant either of the vectors is empty , the other soldier wins .
137 |
138 | To keep count of the states, one can use stl::map of a pair of vectors , where the first vector would represent the set of cards of soldier 1 and the second vector for soldier 2. One can map the pair of vector with bool values which represent whether that state is already visited or not.
139 |
140 |
Editorial
146 |
147 |
148 | **Explanation** :
149 | Let the colour of T-shirt which buyer wants be x. So our task is to find the T-shirt having that colour on any of back or front side and remove it from our available collection of T-shirts.
150 |
151 | Here as our collection of data from which we want to select minimum is dynamic( i.e it is updating after removing each T-shirt) ,so we will use priority_queue that have both update and query(for minimum) in O(log(n)) time complexity;
152 |
153 | We can use priority_queue of pair ```
Editorial
161 |
162 |
163 | **Prerequisite** : Priority queue or Set , Creating your own comparator functions
164 | **Explanation** :
165 | Create a priority queue to store segments, such that the segment having the greatest length is always at the top of priority queue. (If 2 segments have same length, the one with leftmost starting point will be at the top, as per given question)
166 | Now, perform the sequence of operations, as given in the problem.
167 | **Time Complexity** : O(N log N), where N = size of array
168 | [ Since, insertion and deletion in priority queue takes only O( log N ) ]
169 | **Code** : [https://codeforces.com/contest/1353/submission/80121041](https://codeforces.com/contest/1353/submission/80121041)
170 |
171 |
Editorial
177 |
178 |
179 | **Prerequisite** : Map, Iterators in STL
180 | **Explanation** :
181 | It is clear that radius of sphere with rectangle of sides (a,b,c) will be min(a,b,c)/2 and if two parallelepipeds exist with two same side (a,b) then after glueing these two together , radius will be min(a,b,c1+c2)/2.
182 | For every pair (a,b) let us find maximal adjacent sides c1 and c2
183 | ,then we will check for which pair(a,b) min(a,b,c1+c2) is
184 | maximum.
185 | We can make a map of pair to (vector of pair) . In which for every
186 | distinct pair (a,b) we store what is the third side and
187 | corresponding index.
188 | Then we iterate through the map and find maximal c1 and c2 for
189 | every pair (a,b).
190 | Then we find for which pair min(a,b,c1+c2) is maximum and
191 | output the corresponding answer.
192 | **NOTE**: Do not forget when there is only one maximal side for
193 | pair (a,b).
194 |
195 |
Editorial
201 |
202 |
203 | **Pre-requisite** : Map
204 | **Explanation** : We can clearly see than n ≤ 10^5, that is a naive approach of O(n^2) will not pass. We need a better solution.
205 | Here using STL map will make our task easy.
206 | We can make a map of string and int where string will contain the name of person while int will contain the count.
207 | We know that by default map are initialized with zero.
208 | So if the count of a string is zero print OK and increase its counter by 1 else print the string and the count of string and increase its counter by 1.
209 |
210 |
Editorial
218 |219 | 220 | [View here](https://discuss.codechef.com/t/anuund-editorial/5472) 221 | 222 |
223 |Editorial
228 |229 | 230 | [View here](https://discuss.codechef.com/t/anumla-editorial/7713) 231 | 232 |
233 |38 | The function $F(n)$ is defined as the product of square of primes up to $n$ (inclusive).
39 | For eg. $F(5) = 2^2 \cdot 3^2 \cdot 5^2 = 900$ .
40 | **Constraints** 41 | 42 | - $1 \leq x,m \leq 10^9$ 43 | - $2 \leq n \leq 10^6$ 44 | 45 |
50 | Also, one could easily observe that the value of $F(n)$ would definitely overflow for larger values of $n$. So, we can't find $F(n)$ directly.
51 | Here, we can use the property $a^{b \cdot c} = {(a^b)}^c$ . For finding ${a^b} \bmod m$ , use binary exponentation, which works in $O(\log_2 b)$ .
52 | 53 | **Final time complexity**: $O(n \log_2 n)$ 54 | 55 |
130 | $A = a \cdot m$
131 | $B = A \cdot (b + c)$
132 | $C = 5 \cdot B + A \cdot (floor(\log_{10}{(b \cdot c)}))$
133 | You task is to computer $f(n)$ % $m$ where
134 | $f(i) = (A \cdot i^9 + i^i \cdot (B \cdot i!+1) + C \cdot i^{i^i}) \cdot f(i-1)$
135 | Note : $f(0) = 1$ 136 | 137 | **Constraints** 138 | 139 | - $1 \leq n \leq 10^{18}$ 140 | - $1 \leq m \leq 10^6$ 141 | - $1 \leq a,b,c \leq 10^{12}$ 142 | 143 |
147 | 148 | 149 | $A \bmod m = B \bmod m = C \bmod m = 0$
150 | 151 | Thus, applying the properties of modulo arithmetic, we get :
152 | 153 | $f(i) \bmod m = (i^i \cdot f(i-1)) \bmod m$
154 | 155 | Also note one thing, when $n >= m$ , $f(n)$ would be a multiple of m. So, in this case, $f(n) \bmod m = 0$
156 | 157 | Only remains is the case when when $n
160 | 161 | **Final time complexity**: $O(m \log_2 m)$ 162 | 163 |
230 | Since the vendors are lazy so they want you to find the minimum range $E$ such that all the kids in Candyland can get candies.
231 | 232 | **Constraints** 233 | 234 | - $1 \leq n,k \leq 10^4$ 235 | - $10^{-9} \leq X_i \leq 10^{9}$ 236 | 237 |
242 | The lower-limit for $E$ would be 0 and upper-limit for $E$ can be taken as the difference of the highest and the lowest x-coordinates.
243 | Sort the array of x-coordinates at the beginning once. Now, in the predicate function, it becomes very easy to check whether for a given value of range $E = x$, is it possible that all kids can get candies ? 244 | 245 |
Each index $i ∈ [1,N]$ has an initial weight of $W_i$ units. You have to perform $Q$ queries. The queries can be of 2 types:
334 | 335 | Type $1$: $1$ $X$
336 | Type $2$: $2$ $V$ $L$ $R$
337 | Type $1$ queries ask you to increase the weight of all indices by $X$ units.
338 | 339 | Type $2$ queries ask you to calculate the total weight contributed by elements having value $V$ in the index range $[L,R]$
340 | 341 | **Constraints** 342 | 343 | - $1 \leq N,Q \leq 5 \cdot 10^5$ 344 | - $1 \leq A_i,V \leq 2000$ 345 | - $0 \leq W_i, X \leq 100$ 346 | - $1 \leq L \leq R \leq N$ 347 | 348 |
353 | 354 | For each $i \in [0,2001]$ , maintain $2$ arrays, one array should contain the positions of elements having value $i$ and other array should contain the prefix sum of weights corresponding to the saved positions.
355 | 356 | For each query of type $2$, use binary search to get the range of indices of favourable positions in the array maintained for value $V$, 357 | print the difference of prefix sums for new range of
$indices+count\cdot extra$ , where $count$ = count of indices in the new range.
358 | 359 |
443 | 444 | He thinks that 'wellness' of a subset $M$ ⊆ $S$ is equal to the maximum of $gcd(a,b)$ over all pairs $(a,b)$ such that both $a$ and $b$ are in $M$ and $a \neq b$.
445 | 446 | Rahul is an organized guy and for each $k$ ∈ {$2,3,…,N$} he wants to find a subset that has the smallest wellness among all subsets in $S$ of size $k$. There can be more than one subset with the smallest wellness and the same size, but you don't need to worry about it. Rahul wants to find all the subsets himself, but he needs your help to find the smallest possible wellness for each size $k$, will name it $I_k$.
447 | 448 | Please, help Rahul to find $I_2, I_3, ..., I_n$.
449 | 450 | **Constraints** 451 | 452 | - $2 \leq N \leq 5 \cdot 10^5$ 453 | 454 |
459 | 460 | If for any number $a_i$ in $A$ not all of its divisors contained in $A$ then we can replace $a_i$ with one of its divisor. 461 | The size of the subset does not change and wellness may only decrease. Then we can assume that for any $a_i$ all of its divisors contained in $A$.
462 | 463 | Let $d(n)$ be the greatest divisor of $n$ exclude $n$ ($d(1)=1$). Since $A$ contains element with its divisors then smallest gcd of pair of an elements not less than maximum of $d(a_i)$ over elements of $A$ (because $A$ contains $a_i$ with $d(a_i)$). And for any element $a_i$ there is no element $a_j
464 | 465 | After this observation we can just sort elements {$1,...,n$} by theirs $d(∗)$ and take smallest $k$ for every $2\leq k \leq n$. You can calculate $d(∗)$ using the sieve of Eratosthenes. 466 | 467 | **Final time complexity**: $O(n \cdot log(n))$ 468 | 469 |