Search is not available for this dataset
name stringlengths 2 88 | description stringlengths 31 8.62k | public_tests dict | private_tests dict | solution_type stringclasses 2
values | programming_language stringclasses 5
values | solution stringlengths 1 983k |
|---|---|---|---|---|---|---|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int num, l, r, d, x;
x = 0;
cin >> num;
for (int i = 0; i < num; i++) {
cin >> l >> r >> d;
x = d;
while (true) {
if (x <= r && x >= l) {
x = ceil((double)r / d) * d;
break;
} else
break;
}
cout <<... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.*;
public class MinimumInteger {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
while(T-- > 0) {
int l = sc.nextInt();
int r = sc.nextInt();
int d = sc.nextInt();
if (d == 1... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
static_assert(D >= 1, "Vector dimension must be greater than zero!");
template <typename... Args>
Vec(int n = 0, Args... args)
: vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {}
};
templ... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.io.*;
import java.util.*;
public class A58
{
public static void main(String[] args) {
int q, l, r, d, z, a, b;
Scanner sc = new Scanner(System.in);
q=sc.nextInt();
while(q-->0)
{
l=sc.nextInt();
r=sc.nextInt();
d=sc.nextInt();
if(d==1)
System.out.println(d);
else if(d>=l && d... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int t = input.nextInt();
for(int i = 0 ; i < t ; i++){
int l = input.nextInt();
int r = input.nextInt();
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
int a, b, c;
int n;
cin >> a >> b >> c;
if (c < a)
arr[i] = c;
else {
n = b / c;
arr[i] = (n + 1) * c;
}
}
for (int i = 0; i < n; i++) cout << arr[i... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.Scanner;
public class main
{
public static void main(String []args)
{
Scanner s=new Scanner(System.in);
int q=s.nextInt();
for(int i=0;i<q;i++)
{
int l,r,d,ans=0;
l=s.nextInt();
r=s.nextInt();
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python3 | q = int(input())
while q>0:
l,r,d = map(int,input().split())
if d == 1:
print("1")
else:
if l > d:
print(l - l%d)
else:
print(r+d-r%d)
q = q - 1 |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long t;
cin >> t;
while (t--) {
long l, r, d;
cin >> l >> r >> d;
long r1 = l / d;
long r2 = r / d;
if (r1 == 0 && r2 != 0) {
cout << (d * (r2 + 1)) << endl;
} else if (r1 != 0 && r2 != 0) {
cout << (d * (r2 + 1)) << en... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python3 | import math
q = int(input())
def next_divsor(r, d):
pass
for i in range(q):
l,r, d = list(map(int, input().split()))
if d < l or d > r:
print(d)
else:
if r % d == 0:
print(r + d)
else: print((r - (r % d)) * 2)
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, l, r, d, ans;
cin >> t;
while (t--) {
cin >> l >> r >> d;
if (l > d) {
cout << d << endl;
} else if (l <= d) {
if (r < d)
cout << d << endl;
else {
if (r % d == 0)
cout << r + d << e... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int q, l, r, d;
cin >> q;
while (q != 0) {
if (d < l)
cout << d;
else
cout << l + d - l % d;
q--;
}
}
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | /* package codechef; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
public static void main (String[] args) throws java.lang.Exception
{
// your code goes here
Scanner sc = ne... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
struct node {
long long l;
long long r;
long long d;
long long x;
} x[505];
int i, j, k, t;
int main() {
int q;
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%lld%lld%lld", &x[i].l, &x[i].r, &x[i].d);
}
for (i = 0; i < q; i++) {
if (x[i].d > x[i].r) {
x[i].x ... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python2 | entrada = int(raw_input())
for num in range(entrada):
valor = list(map(int,raw_input().split()))
if (valor[0]) > (valor[2]):
resultado = (valor[2])
else:
resultado2 = ((valor[1]) / (valor[2]) + 1)
resultado = (resultado2 * (valor[2]))
print(resultado)
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class codeforces
{
public static void main( String[] args ) throws IOException
{
Reader.init(System.in);
int query = Reader.nextInt();
for( int q =... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int t = input.nextInt();
for(int i = 0 ; i < t ; i++){
int l = input.nextInt();
int r = input.nextInt();
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python2 | from sys import stdin
import math
def minInt(x):
return 6
if len(x) < 3:
return -1
li = int(x[0])
ri = int(x[1])
di = int(x[2])
if di < li:
return di
elif di >= li and di < ri:
return int(math.ceil(ri/di+1)*di)
else:
return int(math.ceil((ri-1)/di+1)*di)
queries = int(raw_input())
result = []
while qu... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long long i = 0, j = 0, r = 0, n, a, b, c, y = 0, l = 0, u = 0, d = 0,
min1 = 0, min2 = 0;
vector<long long> vec, sor(100001, -10);
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b >> c;
if (a > c)
cout << c;
else {
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
int n, a;
cin >> n;
int l, r, d;
for (int i = 0; i < n; i++) {
cin >> l >> r >> d;
cout << (l - d <= 0 ? r - (r % d) + d : (l % d == 0 ? 1 : d)) << endl;
}
return 0;
}
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long l, r, d, check, flag, res, div;
cin >> l >> r >> d;
if (d == 1) {
if (l > 1)
cout << "1" << endl;
else
cout << r + 1 << endl;
continue;
}
if (l > d) {
che... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long N = 1e5, N2 = 2e5, N1 = 1e6, M = 1e2;
long long binpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans *= a;
a *= a;
n >>= 1;
}
return ans;
}
string s, s1, s2;
long long n, m, t, x, y, z;
long long k, k1, k2, g, ... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python3 | a= int(input())
for i in range(a):
b=input()
actual= b.split()
l=int(actual[0])
r=int(actual[1])
d=int(actual[2])
num=1
while l<d*num<r:
num+=1
print(d*num) |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.Scanner;
/**
* @author: miaolei
* @date: 2019/1/18
* @description:
*/
public class SolutionCF1101A {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int q = scan.nextInt();
for (int i = 0; i < q; i++) {
int l = scan.nextInt(... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Stack;
public class ads {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int q=sc.nextInt();
for(int i=0;i<q;i++) {
int l=sc.nextInt();
int r=sc.nextInt();
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;
public class Solution
{
static class InputReader
{
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
public Input... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class codeforces
{
public static void main( String[] args ) throws IOException
{
Reader.init(System.in);
int query = Reader.nextInt();
for( int q =... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python3 | q = int(input())
intervalo = []
contador = 1
for i in range(q):
entrada = input().split(" ")
l = int(entrada[0])
r = int(entrada[1])
d = int(entrada[2])
if(l > d):
print(d)
else:
print(int((r/d+1)*d))
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.io.*;
import java.util.*;
public class minimuminteger {
public static long minimum_integer(long l, long r, long d) {
long min = 0, tmp = 0;
int i = 0;
while (true) {
++i;
tmp = d * i;
if ((tmp < l && tmp < r) || (tmp > l && tmp > r)) {
min = tmp;
break;
}
}
++i;
tmp = d * i... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | var q=parseInt(readline());
for(var i=0;i<q;i++){
var s=readline().split(" ");
var l=parseInt(s[0]),r=parseInt(s[1]),d=parseInt(s[2]);
if(l<=d){
var y=r+1;
while(y%d!==0){y++;}print(y);}
else if(l>d){
var y=l-1;
while(y%d!==0){y--;}print(y);}
}
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int l, r, k;
int o = r / k;
for (int i = 0; i < n; i++) {
cin >> l >> r >> k;
if (k > r || k < l) {
cout << k << endl;
} else if (k <= r && k >= l && r / k == 1) {
cout << k * (o + 1) << endl;
}
}
retur... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r, x = 1, d;
int q;
cin >> q;
while (q--) {
long long i = l;
cin >> l >> r >> d;
if (l != d && l / d >= d)
cout << d << endl;
else
cout << (r / d + 1) * d << endl;
}
return 0;
}
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
public class Main {
public static... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d;
else if (d > r)
cout << d;
else {
r /= d;
r++;
cout << r * d;
}
}
return 0;
}
|
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python2 | t=input()
while t:
t=t-1
l,r,d=raw_input().split()
l=int(l)
r=int(r)
d=int(d)
for w in range(1,501,1):
if l<=d*w<=r:
continue
else:
print d*w
break
... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | python2 | t = input()
while t:
t -= 1
ip = map(int, raw_input().split())
l, r, d = ip[0], ip[1], ip[2]
flag = False
for i in range(1, l):
if i % d == 0:
print i
flag = True
break
if flag:
break
m = 1000000005L
i = r + 1
while i < m:
i... |
1101_A. Minimum Integer | You are given q queries in the following form:
Given three integers l_i, r_i and d_i, find minimum positive integer x_i such that it is divisible by d_i and it does not belong to the segment [l_i, r_i].
Can you answer all the queries?
Recall that a number x belongs to segment [l, r] if l ≤ x ≤ r.
Input
The first l... | {
"input": [
"5\n2 4 2\n5 10 4\n3 10 1\n1 2 3\n4 6 5\n"
],
"output": [
"6\n4\n1\n3\n10\n"
]
} | {
"input": [
"20\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 1000000000 2\n1 100000... | IN-CORRECT | java | import java.util.Scanner;
import java.lang.Math;
public class MinimumInteger{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int t;
t = sc.nextInt();
int[] l = new int[t];
int[] r = new int[t];
int[] d = new int[t];
int flag =1;
for(int i=0;i<t;i++){
l[i] = sc... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 500 - 1) / 500)],
dq[((100000 + 500 - 1) / 500)][500 + 1 + 500];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (500 + 1 + 500) * sizeof *qq);
for (i = (h + 1) * 500; i > h * 500; i--) {
t += bb[i];
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
struct bucket {
long long size, minm;
vector<long long> off;
vector<long long> dps;
vector<long long> pre;
bucket(long long b) {
size = b;
off = vector<long long>(b);
pre = vector<long long>(b);
dps = vector<long long>(b)... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | java | import java.io.*;
import java.util.*;
public class CF1129D {
static final int MD = 998244353, A = 100000, B = 500;
static int[] bb, dp, ss;
static int[][] dq;
static void update(int h) {
int[] qq = dq[h];
Arrays.fill(qq, 0);
int t = 0;
for (int i = (h + 1) * B; i > h * B; i--) {
t += bb[i];
qq[B + t... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100002;
const int MOD = 998244353;
const int MAGIC = 200;
const int MAX_BLOCK = MAX_N / MAGIC + 7;
const int INF = 1e9;
int n, k, prv[MAX_N], pos[MAX_N], a[MAX_N];
int nBlock, L[MAX_BLOCK], R[MAX_BLOCK], blockID[MAX_N];
int v[MAX_N], offset[MAX_BLOCK], hea... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
int const MOD = 998244353;
void add(int& a, int b) {
assert(0 <= a and a < MOD);
assert(0 <= b and b < MOD);
a += b;
if (a >= MOD) a -= MOD;
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, maxu;
std::cin >> n >> maxu;
std::vector<int> a(n);
for (int& x :... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
struct bucket {
int sz, szq, ptr, lz;
pair<int, int> u[250 + 5];
pair<int, int> el[250 + 5];
} B[100005 / 250 + 5];
int n, k, tot;
int a[100005], dp[100005], lnk[100005];
int add(int x, int y) {
x += y;
if (x >= 998244353) x -= 998244353;
if (x < 0) x += 9982443... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, k;
int a[100007];
long long dp[100007];
int prv1[100007];
int prv2[100007];
class bucket {
public:
int st, en;
long long pref[300 + 2];
int val[300 + 2];
int mn = 0;
void recalc() {
int curr = val[0];
for (int i = st; i <= en; ++i) {
curr = (... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = (c & 15);
while (isdigit(c = getchar())) v = (v << 1) + (v << 3) + (c & 15);
x = v * f;
}
inline void read(lo... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkMax(T &x, T y) {
if (y > x) x = y;
}
template <typename T>
void chkMin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
void inline read(T &x) {
int f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 183 + 3;
int bel[N], f[N], g[N], tag[M], s[M][183 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 140 + 3;
int bel[N], f[N], g[N], tag[M], s[M][140 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, mod = 998244353;
int n, m, B;
int a[N], pos[N], bel[N], lst[N], f[N], cnt[N], delta[440], ans[440],
sum[440][N];
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9')
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000 * 100 + 1;
const int Q = 100;
const int MOD = 998244353;
const int UNDEF = -10;
int a[MAXN];
int b[MAXN];
int pr[MAXN];
int prpr[MAXN];
int dp[MAXN];
int sum_dp[MAXN / Q + 10][2 * Q + 1];
int sum[MAXN / Q + 10];
int n, k;
void relax(int& x) {
while (... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | java | import java.io.*;
import java.util.*;
public class A {
public static void main (String[] args) {
// int tests = 1000;
// while(tests-->0) {
// new A();
// }
new A();
}
int SIZE;
int[] dp, lastOcc, lastOcc2, actVals, Ls, Rs, sumBlock;
int[][] dpSum;
public A() {
// try { new TestGen(); } catch (Except... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int B = 300;
const int mod = 998244353;
const int N = 1e5 + 10 + B;
int n, k, arr[N];
int memo[N];
int which(int i) { return i / B; }
void mod_add(int &a, int b) { a = (a + 1LL * b) % mod; }
struct bucket {
int ID;
int offset = 0;
int cnt[B];
int prefix[B];
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | java | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
/**... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, mod = 998244353;
int n, m, B, a[N], pos[N], bel[N], lst[N], f[N], cnt[N], delta[440], ans[440],
sum[440][N];
void update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + mod) % mod;
if (cnt[u] + delta[t] <= m) ans[t]... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int SIZE = 500;
int n, k;
vector<int> dp;
vector<int> pos;
vector<int> offset;
vector<vector<int>> sum;
const int MOD = 998244353;
int plusM(int lhs, int rhs) {
int res = lhs + rhs;
return res >= MOD ? res - MOD : res;
}
int minusM(int lhs, int rhs) {
return lhs... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, a[100001], pos[100001], pre[100001], b[100001], dp[100001],
c[((100001 / 320) + 1)][2 * 320 + 1], s[((100001 / 320) + 1)];
int GetBlockNumber(int i) { return i / 320 + (i % 320 != 0); }
void UpdateBlock(int k) {
s[k] = 0;
for (int i = 0; i <= 2 * 320; ++i)... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int t = 399, mod = 998244353;
inline int mo(const register int x) { return x >= mod ? x - mod : x; }
int a[100010], n, k, bl[100010], p[100010], pre[100010], sum[400][100010],
f[400], S[400], dp[100010], lst[100010];
inline void rebuild(const register int x, const... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int n, k;
inline int ad(int& x, int& y) { return (x + y > P ? x + y - P : x + y); }
int A[200006], las[200006], pr[200006];
const int blo = 200;
int bel[200006];
pair<int, int> B[200006];
int S[200006];
int val[200006], gv[200006], lz[200006], cur;
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9') break;
if (c == '-') goto s;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(b... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int f[100010], val[100010], sep[100010], cnt, k, h[100010], last[100010], n;
int read() {
int tmp = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp;
}
s... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MX_N = 1e5 + 5;
const int MX_K = 1e5 + 5;
const int MX_A = MX_N;
const int MOD = 998244353;
const int B = 300;
int N, K, A[MX_N];
int pos[MX_A], prv[MX_N], dp[MX_N];
struct Bucket {
int pre[B], cnt[B], offset;
Bucket() {
for (int i = (0); i <= (B - 1); ++i... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void ckmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void ckmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const int MOD = 9... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 100005;
const int B = 620;
int n, k, a[N];
int dp[N];
int cnt[N];
vector<int> occ[N];
int delta[B];
vector<int> vet[B];
vector<int> psum[B];
void add(int &aa, int b) { aa = aa + b >= mod ? aa + b - mod : aa + b; }
void rebuild(int id... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, Siz, num[100010], pos[100010], bel[100010], lst[100010], f[100010],
cnt[100010], delta[100010], ans[100010], sum[440][100010];
void update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delt... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
namespace zyt {
template <typename T>
inline bool read(T &x) {
char c;
bool f = false;
x = 0;
do c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF) return false;
if (c == '-') f = true, c = getchar();
do x = x * 10 + c - '0', c = getch... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,popcnt")
using namespace std;
int a[100007], bel[100007], pre[100007], pos[100007], tag[293], delt[100007], n,
k, S;
int f[100007], sum[293][100007 * 2 + 1], ans[293];
const int p = 9... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int __i__, __j__;
class _Debug {
public:
template <typename T>
_Debug& operator,(T val) {
cout << val << endl;
return *this;
}
};
int n, k;
int a[100000], p[100000];
int last[100000];
int dp[100001];
int num[100001];
int sum[350][100100], shift[350];
int suma... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int b = 325;
int dp[100005];
int a[100005], cnt[100005];
int s[100005], e[100005];
vector<int> v[100005];
struct bucket {
int val[2 * b + 5];
int sum = 0;
void rebuild(int s, int e) {
for (int i = 0; i <= 2 * b; i++) val[i] = 0;
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int P = 998244353;
int n, m, a[N], pre[N], rec[N], f[N];
inline void add(int &x, int y) {
x += y;
if (x >= P) x -= P;
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += P;
}
struct BL {
int bel[N], tag[450], w[N], size, cnt, su... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 1e5 + 79, s = 350, ns = maxn / s + 5;
int n, k;
vector<int> f(maxn, 0), a(maxn), dp(maxn, 0), myval(ns, 0);
vector<vector<int> > oc(maxn), sum(ns, vector<int>(s * 2 + 2, 0));
void add(int& a, const int& b) {
a += b;
if (... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAXN = 2e5;
const int B = 315;
int cnt[MAXN], dp[MAXN];
vector<int> occ[MAXN];
void add_self(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void min_self(int &x, int y) { x = min(x, y); }
struct SQRT {
int id, offset, pref_sum[... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int tzu = 500;
int bs = 350;
int n, k;
int a[100001];
int l[100001];
int p[100001];
int dp[100001];
int v[100001];
int sum[501];
int cnt[501][1001];
int mn[501], mx[501];
int m;
void ref(int bl) {
int curv = tzu;
for (int i = mn[bl... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 200 - 1) / 200)],
dq[((100000 + 200 - 1) / 200)][200 + 1 + 200];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (200 + 1 + 200) * sizeof *qq);
for (i = (h + 1) * 200; i > h * 200; i--) {
t += bb[i];
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
const int Bs = 317, N = 2e5 + 10, mod = 998244353;
int ri() {
char c = getchar();
int x = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c;
return x * f;
}
int pr[N], las[N], a[N... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
int sz = t.size();
for (int i = 0; i < s... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
struct sqrt_decomp {
long long n, b;
vector<long long> values;
vector<long long> prefix;
vector<long long> woff;
vector<long long> w;
sqrt_decomp(long long n) {
b = sqrt(n);
if (b * b != n) {
b++;
}
this->b ... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 250 + 3;
int bel[N], f[N], g[N], tag[M], s[M][250 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, B, a[100005], pos[100005], bel[100005], lst[100005], f[100005],
cnt[100005];
int delta[450], ans[450], sum[450][100005];
void Update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delta[t] <... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353, dt = 320;
int b[100010], a[100010], pre[100010], d[100010];
int f[100010];
int q[320][645];
int n, k, now;
int sum[320];
inline int mo(int x) {
if (x >= MOD) return x - MOD;
return x;
}
void ins(int x, int y) {
b[x] = y;
int z = x / dt;
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T Pow(T a, T b, T p) {
T ret = 1;
a %= p;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) (ret *= a) %= p;
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1, mod = 998244353, b_sz = 500;
int n, k;
int last_occ[maxn], prev_occ[maxn];
int delta[maxn];
int dp[maxn];
int tot_delta[201], psums[201][2 * b_sz + 1];
void update(int i) {
vector<int> blocks = {i / b_sz};
if (i % b_sz == 0 and i) {
blocks.... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch = getchar();
x = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - 48, ch = getchar();
}
struct Arr {
int x, y;
} b[100000 + 1], c[320 + 1];
int a[100000 + 1], s[100000 + 1... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize(3)
const int N = 100005, B = 320, M = 998244353;
using namespace std;
int n, k, ti, a[N], occ[N], pre[N], b[N], f[N], sum[B], q[B][B << 1 | 1], now;
inline void mdf(int x, int y) {
b[x] = y;
int z = x / B;
if (z == now) return;
sum[z] = 0;
for (int i = 0; i <= B <... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, m, B, a[100005], pos[100005], bel[100005], lst[100005], f[100005],
cnt[100005];
int delta[450], ans[450], sum[450][100005];
void Update(int u, int v) {
int t = bel[u];
sum[t][cnt[u]] = (sum[t][cnt[u]] - f[u] + 998244353) % 998244353;
if (cnt[u] + delta[t] <... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int B = 320;
const int N = 100000;
const int P = 998244353;
inline int add(int x, int y) {
x += y;
return x >= P ? x - P : x;
}
inline int sub(int x, int y) {
x -= y;
return x < 0 ? x + P : x;
}
inline int mul(int x, int y) { return (int)(1LL * x * y % P); }
i... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int SZ = 320;
const long long MOD = 998244353;
int N, K;
int prv[MAX_N + 1];
int arr[MAX_N + 1];
int pidx[MAX_N + 1];
int num[MAX_N + 1];
long long dp[MAX_N + 1];
long long dp2[SZ + 1][MAX_N + 1];
long long D;
int add[SZ + 1];
void Update(int... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& i : v) os << i << ' ';
return os;
}
template <typename T, typename U>
ist... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
const long long mod = 998244353;
const int bsize = 75;
int cnt[maxn];
int dp[maxn];
int n, k;
vector<int> occurences[maxn];
class bucket {
public:
int id;
int first, last;
int offset, smallest;
int pref[bsize + 5];
void build() {
firs... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c h, c n) {
return {h, n};
}
template <class c>
auto dud(c* r) -> decltype(cerr << *r);
template <class c>
char dud(...);
struct muu {
template <class c>
muu& opera... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
const int Bs = 317, N = 2e5 + 10, mod = 998244353;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
template <typename T>
void add(T &x, T y, T mod) {
x = x + y > mod ? x + y - mod : x + y;
}
template <... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
int q, sum[320][2 * 320], tot[320];
int dp[100009], last[100009], last2[100009], v[100009];
inline void add(int &a, int b) {
a += b;
if (a >= 998244353) a -= 998244353;
}
inline void update(int t) {
memset(sum[t], 0, sizeof sum[t]);
int cnt = 0;
for (int i = t * q + q; i > t * q; i--)... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 11, mod = 998244353;
int ans, n, k, blo, bel[N], f[N], g[N], a[N], L[N], R[N], las[N], bef[N],
lim[N], sum[411][N], Sum[411];
inline void inc(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline void deal(int l, int r, int x) {
int o = bel... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
int n, k, nr_b;
int t[500010], dp[500010], cnt[500010];
vector<int> _last[500010];
int f(int x) {
if (x >= 998244353)
return x - 998244353;
else
return x;
}
struct bucket {
int offset;
int bucket_id;
vector<int> pref_sum;
bucket() {
offset = 0;
b... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
using namespace std;
int mod = 998244353;
int A[100077];
int B[100077];
int N[100077];
int dp[100077];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, k, ai;
cin >> n >> k;
dp[0] = 1;
signed long long sum = 1;
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 7;
const long long MOD = 998244353;
const long long PIERW = 100;
int ciag[MAX];
int ostatnie[MAX];
int poprzedni[MAX];
long long pomocnicza[MAX];
long long DP[MAX];
struct Blok {
int lewa, prawa;
long long suma;
long long sumaDP[PIERW * 2 + 1];
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
int bb[1 + 100000], dp[1 + 100000], ss[((100000 + 200 - 1) / 200)],
dq[((100000 + 200 - 1) / 200)][200 + 1 + 200];
void update(int h) {
int *qq = dq[h];
int i, t, c;
t = 0;
memset(qq, 0, (200 + 1 + 200) * sizeof *qq);
for (i = (h + 1) * 200; i > h * 200; i--) {
t += bb[i];
... |
1129_D. Isolation | Find the number of ways to divide an array a of n integers into any number of disjoint non-empty segments so that, in each segment, there exist at most k distinct integers that appear exactly once.
Since the answer can be large, find it modulo 998 244 353.
Input
The first line contains two space-separated integers n... | {
"input": [
"5 5\n1 2 3 4 5\n",
"3 1\n1 1 2\n",
"5 2\n1 1 2 1 3\n"
],
"output": [
"16",
"3",
"14"
]
} | {
"input": [
"50 1\n50 8 46 9 12 38 41 18 49 10 23 15 16 3 13 17 48 8 31 32 6 31 31 49 9 40 9 21 23 41 17 31 45 47 17 1 12 15 50 40 38 4 20 1 9 37 4 47 4 24\n",
"100 30\n31 57 26 94 41 92 88 4 46 51 64 45 89 59 91 49 3 28 17 63 9 74 77 60 83 30 73 64 90 47 34 80 94 89 66 31 19 84 86 83 62 59 96 67 93 58 7 86 ... | CORRECT | cpp | #include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int n, k;
inline int ad(int& x, int& y) { return (x + y > P ? x + y - P : x + y); }
int A[200006], las[200006], pr[200006];
const int blo = 233;
int bel[200006];
pair<int, int> B[200006];
int S[200006];
int val[200006], gv[200006], lz[200006], cur;
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.