CF 210 Div2

最新推荐文章于 2022-05-02 22:23:52 发布
最新推荐文章于 2022-05-02 22:23:52 发布
阅读量1.5k 收藏
点赞数
分类专栏： CF 文章标签： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm_xmzhou/article/details/15339005
版权
A. Levko and Table
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

Levko loves tables that consist of n rows and n columns very much. He especially loves beautiful tables. A table is beautiful to Levko if the sum of elements in each row and column of the table equals k.

Unfortunately, he doesn't know any such table. Your task is to help him to find at least one of them.

Input

The single line contains two integers, n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1000).

Output

Print any beautiful table. Levko doesn't like too big numbers, so all elements of the table mustn't exceed 1000 in their absolute value.

If there are multiple suitable tables, you are allowed to print any of them.

Sample test(s)
input 
2 4
output 
1 3
3 1
input 
4 7
output 
2 1 0 4
4 0 2 1
1 3 3 0
0 3 2 2
Note

In the first sample the sum in the first row is 1 + 3 = 4, in the second row — 3 + 1 = 4, in the first column — 1 + 3 = 4 and in the second column — 3 + 1 = 4. There are other beautiful tables for this sample.

In the second sample the sum of elements in each row and each column equals 7. Besides, there are other tables that meet the statement requirements.

题意是给你n和k，让你构造一个n*n的矩阵使得该矩阵的行之和，列之和均为k。

直接YY即可。

/*
ID: xinming2
PROG: stall4
LANG: C++
*/
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <map>
#include <string>
#include <stack>
#include <cctype>
#include <vector>
#include <queue>
#include <set>
#include <utility>
#include <cassert>
using namespace std;
///#define Online_Judge
#define outstars cout << "***********************" << endl;
#define clr(a,b) memset(a,b,sizeof(a))
#define lson l , mid  , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define mk make_pair
#define FOR(i , x , n) for(int i = (x) ; i < (n) ; i++)
#define FORR(i , x , n) for(int i = (x) ; i <= (n) ; i++)
#define REP(i , x , n) for(int i = (x) ; i > (n) ; i--)
#define REPP(i ,x , n) for(int i = (x) ; i >= (n) ; i--)
const int MAXN = 30 + 5;
const int sigma_size = 26;
const long long LLMAX = 0x7fffffffffffffffLL;
const long long LLMIN = 0x8000000000000000LL;
const int INF = 0x7f7f7f7f;
const int IMIN = 0x80000000;
#define eps 1e-8
const int mod = (int)1e9 + 7;
typedef long long LL;
const LL MOD = 1000000007LL;
const double PI = acos(-1.0);

typedef pair<int , int> pi;
#define Bug(s) cout << "s = " << s << endl;
///#pragma comment(linker, "/STACK:102400000,102400000")
int main()
{
    int n , k;
    while(~scanf("%d%d" , &n , &k))
    {
        for(int i = 0; i < n ; i++)
        {
            for(int j = 0 ;j < n ; j++)
            {
                if(i == j)printf("%d%c" , k , j == n - 1 ? '\n' : ' ');
                else printf("0%c" , j == n - 1 ? '\n' : ' ');
            }
        }
    }
    return 0;
}

———————————————————————————————————————————————————

***********************************************************************************************************************************———————————————————————————————————————————————————

B. Levko and Permutation
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

Levko loves permutations very much. A permutation of length n is a sequence of distinct positive integers, each is at most n.

Let’s assume that value gcd(a, b) shows the greatest common divisor of numbers a and b. Levko assumes that element pi of permutation p1, p2, ... , pn is good if gcd(i, pi) > 1. Levko considers a permutation beautiful, if it has exactly k good elements. Unfortunately, he doesn’t know any beautiful permutation. Your task is to help him to find at least one of them.

Input

The single line contains two integers n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ n).

Output

In a single line print either any beautiful permutation or -1, if such permutation doesn’t exist.

If there are multiple suitable permutations, you are allowed to print any of them.

Sample test(s)
input 
4 2
output 
2 4 3 1
input 
1 1
output 
-1
Note

In the first sample elements 4 and 3 are good because gcd(2, 4) = 2 > 1 and gcd(3, 3) = 3 > 1. Elements 2 and 1 are not good because gcd(1, 2) = 1 and gcd(4, 1) = 1. As there are exactly 2 good elements, the permutation is beautiful.

The second sample has no beautiful permutations.

题意是给你n和k，定义good number为gcd(a[i] , i) > 1 , 请你输出一个长度为n，且含有k个good number的序列。

思路：我们可以肯定相邻两数必然互素，1与任何数互素，那么我们就把k提到首位然后按顺序输出即可。

/*
ID: xinming2
PROG: stall4
LANG: C++
*/
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <map>
#include <string>
#include <stack>
#include <cctype>
#include <vector>
#include <queue>
#include <set>
#include <utility>
#include <cassert>
using namespace std;
///#define Online_Judge
#define outstars cout << "***********************" << endl;
#define clr(a,b) memset(a,b,sizeof(a))
#define lson l , mid  , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define mk make_pair
#define FOR(i , x , n) for(int i = (x) ; i < (n) ; i++)
#define FORR(i , x , n) for(int i = (x) ; i <= (n) ; i++)
#define REP(i , x , n) for(int i = (x) ; i > (n) ; i--)
#define REPP(i ,x , n) for(int i = (x) ; i >= (n) ; i--)
const int MAXN = 30 + 5;
const int sigma_size = 26;
const long long LLMAX = 0x7fffffffffffffffLL;
const long long LLMIN = 0x8000000000000000LL;
const int INF = 0x7f7f7f7f;
const int IMIN = 0x80000000;
#define eps 1e-8
const int mod = (int)1e9 + 7;
typedef long long LL;
const LL MOD = 1000000007LL;
const double PI = acos(-1.0);

typedef pair<int , int> pi;
#define Bug(s) cout << "s = " << s << endl;
///#pragma comment(linker, "/STACK:102400000,102400000")
int a[101100];
int main()
{
    int n , k;
    while(~scanf("%d%d" , &n , &k))
    {
        for(int i = 0;  i< n ; i++)a[i] = i + 1;
        if(k == n)
        {
            puts("-1");
            continue;
        }
        printf("%d" , a[n - k - 1]);
        for(int i = 0 ; i < n - k - 1 ; i++)
        {
            printf(" %d" , a[i]);
        }
        for(int i = n - k ;i < n ; i++)
        {
            printf(" %d" , a[i]);
        }
        printf("\n");
    }
    return 0;
}

———————————————————————————————————————————————————***********************************************************************************************************************************———————————————————————————————————————————————————

C. Levko and Array Recovery
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:

  1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
  2. Find the maximum of elements from li to ri. That is, calculate the value .

Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.

Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n,  - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n,  - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.

The operations are given in the order Levko performed them on his array.

Output

In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.

If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.

Sample test(s)
input 
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
output 
YES
4 7 4 7
input 
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
output 
NO

题意是给你一个n，m，表示对一个长度为n的序列进行m个操作，我们有两种操作：1.将区间l到r的每个数加k ； 2.输出区间最大值。接下来的m行会给你四个数x ， l , r , k 。x表示第几种操作，l , r 表示区间端点，在1操作中k表示每次加的值，在2操作中表示每次取得的最大值。让你输出一个可行的序列，否则输出NO。

思路：记录每个点的add，表示加了多少，记录每个点的ub，表示每个点可行的上界，然后暴力去扫即可，最后向回扫一遍，判断是否成立。

/*
ID: xinming2
PROG: stall4
LANG: C++
*/
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <map>
#include <string>
#include <stack>
#include <cctype>
#include <vector>
#include <queue>
#include <set>
#include <utility>
#include <cassert>
using namespace std;
///#define Online_Judge
#define outstars cout << "***********************" << endl;
#define clr(a,b) memset(a,b,sizeof(a))
#define lson l , mid  , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define mk make_pair
#define FOR(i , x , n) for(int i = (x) ; i < (n) ; i++)
#define FORR(i , x , n) for(int i = (x) ; i <= (n) ; i++)
#define REP(i , x , n) for(int i = (x) ; i > (n) ; i--)
#define REPP(i ,x , n) for(int i = (x) ; i >= (n) ; i--)
const int MAXN = 5050 + 5;
const int sigma_size = 26;
const long long LLMAX = 0x7fffffffffffffffLL;
const long long LLMIN = 0x8000000000000000LL;
const int INF = 0x7f7f7f7f;
const int IMIN = 0x80000000;
#define eps 1e-8
const int mod = (int)1e9 + 7;
typedef long long LL;
const LL MOD = 1000000007LL;
const double PI = acos(-1.0);

typedef pair<int , int> pi;
#define Bug(s) cout << "s = " << s << endl;
///#pragma comment(linker, "/STACK:102400000,102400000")
int ub[MAXN] , n , m , add[MAXN] , Q[MAXN][4];
int main()
{
    int x , l , r , k;
    while(~scanf("%d%d" , &n , &m))
    {
        for(int i = 1 ; i <= n ;  i++)
        {
            add[i] = 0;
            ub[i] = 1000000000;
        }
        clr(Q , 0);
        for(int i = 0 ; i < m ; i++)
        {
            scanf("%d%d%d%d", &x , &l , &r , &k);
            Q[i][0] = x , Q[i][1] = l , Q[i][2] = r , Q[i][3] = k;
            if(x == 1)
            {
                for(int j = l ; j <= r ; j++)
                {
                    add[j] += k;
                }
            }
            else
            {
                for(int j = l ; j <=r ; j++)
                {
                    ub[j] = min(ub[j] , k - add[j]);
                }
            }
        }
//        for(int i = 1; i <= n ; i++)cout << ub[i] << endl;
        bool fg = 0;
        for(int i = 1 ; i <= n ; i++)add[i] = 0;
        for(int i = 0 ; i < m ; i++)
        {
            l = Q[i][1] , r = Q[i][2] , k = Q[i][3];
            if(Q[i][0] == 1)
            {
                for(int j = l ; j <= r ; j++)add[j] += k;
            }
            else
            {
                int j;
                for(j = l ;j  <= r ; j++)if(ub[j] == k - add[j])break;
//                cout << j << endl;
                if(j > r)
                {
                    fg = 1;
                    break;
                }
            }
        }
        printf("%s\n" , fg ? "NO" : "YES");
        if(!fg)
        {
            for(int i = 1 ; i <= n ; i++)
            {
                printf("%d%c" , ub[i] , i == n ? '\n' : ' ');
            }
        }

    }
    return 0;
}

———————————————————————————————————————————————————***********************************************************************************************************************************———————————————————————————————————————————————————

D. Levko and Array
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

Levko has an array that consists of integers: a1, a2, ... , an. But he doesn’t like this array at all.

Levko thinks that the beauty of the array a directly depends on value c(a), which can be calculated by the formula:

The less value  c(a) is, the more beautiful the array is.

It’s time to change the world and Levko is going to change his array for the better. To be exact, Levko wants to change the values of at most k array elements (it is allowed to replace the values by any integers). Of course, the changes should make the array as beautiful as possible.

Help Levko and calculate what minimum number c(a) he can reach.

Input

The first line contains two integers n and k (1 ≤ k ≤ n ≤ 2000). The second line contains space-separated integers a1, a2, ... , an ( - 109 ≤ ai ≤ 109).

Output

A single number — the minimum value of c(a) Levko can get.

Sample test(s)
input 
5 2
4 7 4 7 4
output 
0
input 
3 1
-100 0 100
output 
100
input 
6 3
1 2 3 7 8 9
output 
1
Note

In the first sample Levko can change the second and fourth elements and get array: 4, 4, 4, 4, 4.

In the third sample he can get array: 1, 2, 3, 4, 5, 6.


题意是给你n和k，然后给你一个长度为n的序列，你可以改变k个任意一个元素的大小，请输出最小的改变后数组的最大的任意两个元素之间的差。

思路是二分。

/*
ID: xinming2
PROG: stall4
LANG: C++
*/
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <map>
#include <string>
#include <stack>
#include <cctype>
#include <vector>
#include <queue>
#include <set>
#include <utility>
#include <cassert>
using namespace std;
///#define Online_Judge
#define outstars cout << "***********************" << endl;
#define clr(a,b) memset(a,b,sizeof(a))
#define lson l , mid  , rt << 1
#define rson mid + 1 , r , rt << 1 | 1
#define mk make_pair
#define FOR(i , x , n) for(int i = (x) ; i < (n) ; i++)
#define FORR(i , x , n) for(int i = (x) ; i <= (n) ; i++)
#define REP(i , x , n) for(int i = (x) ; i > (n) ; i--)
#define REPP(i ,x , n) for(int i = (x) ; i >= (n) ; i--)
const int MAXN = 2000 + 5;
const int sigma_size = 26;
const long long LLMAX = 0x7fffffffffffffffLL;
const long long LLMIN = 0x8000000000000000LL;
const int INF = 0x7f7f7f7f;
const int IMIN = 0x80000000;
#define eps 1e-8
const int mod = (int)1e9 + 7;
typedef long long LL;
const LL MOD = 1000000007LL;
const double PI = acos(-1.0);

typedef pair<int , int> pi;
#define Bug(s) cout << "s = " << s << endl;
///#pragma comment(linker, "/STACK:102400000,102400000")
int a[MAXN] , b[MAXN] , sum , k  ,n;
bool ok(int d)
{
    for(int i = 1 ; i<= n; i++)
    {
        b[i] = 1;
    }
    for(int i = 2 ; i <= n ; i++)
    {
        for(int j = 1 ; j <  i ; j++)
        {
            if(abs(a[i] - a[j]) <= (LL)(i - j) * d)
            {
                b[i] = max(b[i] , b[j] + 1);
            }
        }
    }
    sum = 0;
    for(int i = 1 ; i <= n ;i++)sum = max(sum , b[i]);
    return n - sum <= k;
}
int main()
{
    int l = 0 , r = 2*1000000000;
    scanf("%d%d" , &n , &k);
    for(int i = 1 ; i <= n ; i++)scanf("%d" , &a[i]);
    while(l <= r)
    {
        int Mid = ((LL)l + r) / 2;
        if(ok(Mid))r = Mid - 1;else l = Mid + 1;
    }
    printf("%d\n" , l);
    return 0;
}



XMzhou
关注
专栏目录
CF#320 Div.2 总结
Stool_Monster的专栏
09-17 627
比赛网址：cf#320 Div.2 晚上11点开始的比赛，持续2个半小时。结束时有两道题题过了预测数据，分时是A题和C题。 比赛开始的时候，理所当然地从A题开始看起。A题比较容易，稍微分析一下就可以看出是一道10进制转2进制的题目，虽然题目比较简单，但是由于敲代码不够熟练，并且还要测试一些数据的原因，当我提交时已经有接近2000人A了此题。 然后我开始看B题，B题题意比较容易理解，而且我觉得
cf232 div2
冰
02-27 1068
cf 232 div2B. On Corruption and Numbers 输入为m， l ， r 首先看出来组成的所有的数，可以组成区间[l, r]; [2 * l, 2 * r] ... 再则判断m是否在这些区间里即可 以下2种， 3.利用k*l int n; int m, l, r; int main(){ cin >> n; while (n--)
CF-Round#625-div2-D题
qq_44624316的博客
03-17 561
CF-Round#625-div2-D题 D. Navigation System 传送门 一般div1和div2一起的比赛的题目的难度总比单独的div2难度大些。。不知道是不是我的错觉。 这道题dijkstra或者bfs都可以解决=-= 这道题因为没有要求输出路线。所以bfs直接搜出最短路的大小也可以过。 只是=-=emm，原因竟然是dijkstra忘了=-=太久没写了。然后上上个学期的数据结构...
cf337div2 C
xgogoforit的博客
12-30 1340
题目链接：http://codeforces.com/contest/610/problem/C 还是看的卿神的题解…照旧#include<bits/stdc++.h> using namespace std; int dp[1000][1000]; int main(int argc, char const *argv[]) { dp[0][0]=1; int n; sca
CF 251 div2 题解
BUAA_ACM的专栏
06-05 638
官方题解 http://codeforces.com/blog/entry/12545
CF226 div2 B
u012432475的专栏
02-17 873
#include #include #include #include #include #include #include #include //CF226 div2 B #define LL long long #define inf 999999999 using namespace std; char a[5100], p[5]="bear"; int main()
CF 191 div2 C
勿忘初衷
07-17 1852
这倒题找出规律不难，关键是有mod运算，还要求等比数列，直接用公式求，存在除法，不行，所以采用二分的方式。 #include #include #include #include #include #include #include #include typedef long long LL; using namespace std; const int maxn = 500 +
CF207 Div 2 题解
huzecong的博客
10-16 1029
为了不跌成黄名……开个小号玩Div 2……果然Div 2要舒服多了…… A：略…… B： 题意：n个人来跳舞，一共m支舞，每支舞3人，要求这3人的衣服必须一红一蓝一白。保证每支舞的3人中最多有1人是之前跳过舞的。给出一种给n个人衣服染色的方案。保证有解。 解：由于保证每支舞的3人中最多有1人是之前跳过舞的，易得之前的染色不会影响之后的，故直接染就好了。 C： 题意：n名
CF #643 div.2 ABDE
陈颜的博客
05-17 5378
一个月没打cf了，难得打一次，结果D被fst了，又掉分 cf太卡了不想进，因此以下代码仅供参考，不保证ac A题 Sequence with Digits 就是给你一个数n,问你执行k-1次操作后变成多少。 操作：找到n中最大的数和最小的数，n加上这个数。 例如487487487，第一次操作：487+(4×8)=519487+(4\times8)=519487+(4×8)=519，第二次操作：519+(1×9)=528519+(1\times9)=528519+(1×9)=528 这题给的数据是k&lt
CF_DIV2_153
shuimu12345678的专栏
12-08 576
http://codeforces.com/blog/entry/6060
CF题解DIV2
07-09
Oops! Google Chrome could not connect to codeforces.com Try reloading: codeforces.­com Additional suggestions: Access a cached copy of codeforces.­com Search on Google:
cf的div1和div2
最新发布
07-27
在CF比赛中，参赛选手根据他们的水平被分为不同的分级，其中包括Div1和Div2。 Div1（Division 1）是指最高级别的竞赛分级，主要面向那些具有较高编程水平和算法能力的选手。Div1比赛通常包含更加复杂和挑战性的问题...
cf div2 A 1659Red Versus Blue
m0_62167326的博客
05-02 102
【cf1000思维专练】题二
CF#680 Div.2赛后总结
蒟蒻QMQ
11-02 287
文章目录前言ABCDE 前言 哭了啊，又被同机房那几个奆佬摁在地上摩擦，平均比每人少做一道题目。 比赛链接：https://codeforc.es/contest/1445 A 题意：给你两个数组a,ba,ba,b，让你判断能不能通过对bbb重新的排序，让其满足：ai+bi≤k(1≤i≤n)a_{i}+b_{i}≤k(1≤i≤n)ai​+bi​≤k(1≤i≤n)，其中kkk是给定的常数。 做法：不难发现，aaa升序，bbb降序，然后暴力做即可。 时间复杂度：O(nlogn)O(nlogn)O(nlogn)
Codeforces Round 206 DIV 2
XMzhou的专栏
10-14 1723
A. Vasya and Digital Root time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Vasya has recently found out what
CodeForces 148D Bag of mice —— 概率DP
XMzhou的专栏
11-07 967
D. Bag of mice time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output The dragon and the princess are arguing abou
CF 18D Seller Bob
XMzhou的专栏
07-25 786
D. Seller Bob time limit per test 2 seconds memory limit per test 128 megabytes input standard input output standard output Last year Bob earned by selling memory sticks
CF 2B The least round way
XMzhou的专栏
08-26 760
B. The least round way time limit per test 5 seconds memory limit per test 64 megabytes input standard input output standard output There is a square matrix n × n, consi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值