Codeforces Round #663 (Div. 2) A-D

最新推荐文章于 2022-11-22 23:15:14 发布
最新推荐文章于 2022-11-22 23:15:14 发布
阅读量521 收藏
点赞数 3
分类专栏： ACM刷题题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangzijiangac/article/details/107910669
版权

A : S u b o r r a y s A: Suborrays A:Suborrays
思路：
x ∣ y > = m a x ( x , y ) x|y>=max(x,y) x∣y>=max(x,y)，线性输出即可。

参考代码：

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <math.h>
using namespace std;
typedef long long ll;
//#define ll long long
const int N = 2009;
const ll maxn = 1e5 + 20;
const ll mod = 1000000007;
int inv[maxn], vis[maxn], dis[maxn];
int fac[maxn], a[maxn], q[maxn], b[N], c[N];
vector<ll> vec;
//typedef pair<ll, ll> p;
//priority_queue<p, vector<p>, greater<p> > m;
// ll sum[maxn], a[maxn];
ll max(ll a, ll b) { return a > b ? a : b; }
ll min(ll a, ll b) { return a < b ? a : b; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
map<ll, ll> mp;
ll ksm(ll a, ll b)
{
    a %= mod;
    ll ans = 1ll;
    while (b)
    {
        if (b & 1)
            ans = (ans * a) % mod;
        a = (a * a) % mod;
        b >>= 1ll;
    }
    return ans;
}
int dp[N][N];
char s[N][N];
// string p = "abacaba";
// queue<ll> qk, q;
//vector<ll> vec;
// ll sumx[maxn], sumy[maxn], sumk[maxn];
int cnt;
map<int, int> p;
struct node
{
    int ls, rs, sum;
} tr[maxn * 32];
void inser(int &k, int L, int R, int pos, int w)
{
    if (!k)
        k = ++cnt;
    tr[k].sum += w;
    if (L == R)
        return;
    int mid = L + R >> 1;
    if (mid >= pos)
        inser(tr[k].ls, L, mid, pos, w);
    else
        inser(tr[k].rs, mid + 1, R, pos, w);
}
int query(int k, int L, int R, int ik)
{
    if (L == R)
        return L;
    int sk = tr[tr[k].ls].sum;
    int mid = L + R >> 1;
    if (sk >= ik)
        return query(tr[k].ls, L, mid, ik);
    else
        return query(tr[k].rs, mid + 1, R, ik - sk);
}
int lx[N][N], rx[N][N], bl[N][N], br[N][N], wup[N][N], down[N][N];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    //ll t, n, ans;
    // scanf("%lld", &t);
    int t, n;
    cin >> t;
    while (t--)
    {
        cin >> n;
        for (int i = 1; i <= n; i++)
            cout << i << ' ';
        cout << endl;
    }
}

B − F i x Y o u B - Fix You B−FixYou

思路：
由于只能往下走或往右走，所以我们只考虑，最下一行的能否到达，和最右一列的能否到达即可，因为其他的点必然会经过最后一行或者最右一列。

参考代码：

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <math.h>
using namespace std;
typedef long long ll;
//#define ll long long
const int N = 2009;
const ll maxn = 1e5 + 20;
const ll mod = 1000000007;
int inv[maxn], vis[maxn], dis[maxn];
int fac[maxn], a[maxn], q[maxn], b[N], c[N];
vector<ll> vec;
//typedef pair<ll, ll> p;
//priority_queue<p, vector<p>, greater<p> > m;
// ll sum[maxn], a[maxn];
ll max(ll a, ll b) { return a > b ? a : b; }
ll min(ll a, ll b) { return a < b ? a : b; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
map<ll, ll> mp;
ll ksm(ll a, ll b)
{
    a %= mod;
    ll ans = 1ll;
    while (b)
    {
        if (b & 1)
            ans = (ans * a) % mod;
        a = (a * a) % mod;
        b >>= 1ll;
    }
    return ans;
}
int dp[N][N];
char s[N][N];
// string p = "abacaba";
// queue<ll> qk, q;
//vector<ll> vec;
// ll sumx[maxn], sumy[maxn], sumk[maxn];
int cnt;
map<int, int> p;
struct node
{
    int ls, rs, sum;
} tr[maxn * 32];
void inser(int &k, int L, int R, int pos, int w)
{
    if (!k)
        k = ++cnt;
    tr[k].sum += w;
    if (L == R)
        return;
    int mid = L + R >> 1;
    if (mid >= pos)
        inser(tr[k].ls, L, mid, pos, w);
    else
        inser(tr[k].rs, mid + 1, R, pos, w);
}
int query(int k, int L, int R, int ik)
{
    if (L == R)
        return L;
    int sk = tr[tr[k].ls].sum;
    int mid = L + R >> 1;
    if (sk >= ik)
        return query(tr[k].ls, L, mid, ik);
    else
        return query(tr[k].rs, mid + 1, R, ik - sk);
}
int lx[N][N], rx[N][N], bl[N][N], br[N][N], wup[N][N], down[N][N];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    //ll t, n, ans;
    // scanf("%lld", &t);
    int t, n, m;
    cin >> t;
    while (t--)
    {
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
            cin >> (s[i] + 1);
        int ans = 0;
        for (int i = 1; i < m; i++)
        {
            if (s[n][i] != 'R')
                ans++;
        }
        for (int i = 1; i < n; i++)
        {
            if (s[i][m] != 'D')
                ans++;
        }
        cout << ans << endl;
    }
}

C ： C y c l i c P e r m u t a t i o n s C：Cyclic Permutations C：CyclicPermutations
思路：
没啥思路这个，我题其实没怎么看懂，但是几分钟就A了，因为能看出这个是个规律题，那么对于规律题，一般都是阶乘， 2 n 2^n 2n， n k n^k nk之类的，我随意构造了几个，发现第一个过了，第二个也过了，就A了 。

参考代码：

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <math.h>
using namespace std;
typedef long long ll;
//#define ll long long
const int N = 2009;
const ll maxn = 1e5 + 20;
const ll mod = 1000000007;
int inv[maxn], vis[maxn], dis[maxn];
int fac[maxn], a[maxn], q[maxn], b[N], c[N];
vector<ll> vec;
//typedef pair<ll, ll> p;
//priority_queue<p, vector<p>, greater<p> > m;
// ll sum[maxn], a[maxn];
ll max(ll a, ll b) { return a > b ? a : b; }
ll min(ll a, ll b) { return a < b ? a : b; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
map<ll, ll> mp;
ll ksm(ll a, ll b)
{
    a %= mod;
    ll ans = 1ll;
    while (b)
    {
        if (b & 1)
            ans = (ans * a) % mod;
        a = (a * a) % mod;
        b >>= 1ll;
    }
    return ans;
}
ll dp[1000005];
char s[N][N];
// string p = "abacaba";
// queue<ll> qk, q;
//vector<ll> vec;
// ll sumx[maxn], sumy[maxn], sumk[maxn];
int cnt;
map<int, int> p;
struct node
{
    int ls, rs, sum;
} tr[maxn * 32];
void inser(int &k, int L, int R, int pos, int w)
{
    if (!k)
        k = ++cnt;
    tr[k].sum += w;
    if (L == R)
        return;
    int mid = L + R >> 1;
    if (mid >= pos)
        inser(tr[k].ls, L, mid, pos, w);
    else
        inser(tr[k].rs, mid + 1, R, pos, w);
}
ll f()
{
    dp[0] = 1;
    for (ll i = 1; i <= 1000005; i++)
        dp[i] = dp[i - 1] * i % mod;
}
int query(int k, int L, int R, int ik)
{
    if (L == R)
        return L;
    int sk = tr[tr[k].ls].sum;
    int mid = L + R >> 1;
    if (sk >= ik)
        return query(tr[k].ls, L, mid, ik);
    else
        return query(tr[k].rs, mid + 1, R, ik - sk);
}
int lx[N][N], rx[N][N], bl[N][N], br[N][N], wup[N][N], down[N][N];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    //cout << (583291ll * 583291ll % mod) << endl;
    //ll t, n, ans;
    // scanf("%lld", &t);
    ll t, n, m;
    // cin >> t;
    f();
    // while (t--)
    // {
    cin >> n;
    cout << ((dp[n] - ksm(2, n - 1) + mod) % mod) << endl;
    // }
}

D − 505 D - 505 D−505

思路：枚举子集+贪心
可以确定的是当 n > 3 n>3 n>3时无解，因为由于 m > = n m>=n m>=n，所以当 n > 3 n>3 n>3， n , m n,m n,m组成的大矩阵中一定含 4 ∗ 4 4*4 4∗4的小矩阵，证明 4 ∗ 4 4*4 4∗4的矩阵无解如下图：
在这里插入图片描述
所以现在我们可以确定 n n n的范围属于 [ 1 , 3 ] [1,3] [1,3]，显然这么小的数据范围是可以枚举的，所以我们枚举第一列的状态，的到该状态的01序列，通过第一列的状态构造符合条件的矩阵，在构造中获得每一种状态修改的次数，枚举最小值。
若 n = 1 n=1 n=1，答案直接输出 0 0 0即可， n > 3 n>3 n>3输出 − 1 -1 −1， n = 2 ∣ ∣ n = 3 n=2||n=3 n=2∣∣n=3，构造合法答案，显然我们已知第一列的状态，第二列的状态可由给定矩阵构造出，直至构造到第 m m m列，具体操作看一下代码。

参考代码：

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <ctime>
#include <cstring>
#include <cstdlib>
#include <math.h>
using namespace std;
typedef long long ll;
//#define ll long long
const int N = 2009;
const ll maxn = 1e5 + 20;
const ll mod = 1000000007;
int inv[maxn], vis[maxn], dis[maxn];
int fac[maxn], a[maxn], q[maxn], b[N], c[N];
vector<ll> vec;
//typedef pair<ll, ll> p;
//priority_queue<p, vector<p>, greater<p> > m;
// ll sum[maxn], a[maxn];
ll max(ll a, ll b) { return a > b ? a : b; }
ll min(ll a, ll b) { return a < b ? a : b; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
map<ll, ll> mp;
ll ksm(ll a, ll b)
{
    a %= mod;
    ll ans = 1ll;
    while (b)
    {
        if (b & 1)
            ans = (ans * a) % mod;
        a = (a * a) % mod;
        b >>= 1ll;
    }
    return ans;
}
// ll dp[1000005];
// char s[N][N];
// // string p = "abacaba";
// // queue<ll> qk, q;
// //vector<ll> vec;
// // ll sumx[maxn], sumy[maxn], sumk[maxn];
// int cnt;
// map<int, int> p;
int dp[3][1000005];
string matrix[1000005];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t, n, m;
    // cin >> t;
    //f();
    // while (t--)
    // {
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        cin >> matrix[i];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            matrix[i][j] -= '0';
    if (n == 1)
        cout << 0 << endl;
    else if (n >= 4)
        cout << -1 << endl;
    else
    {
        int ans = 999999999;
        for (int i = 0; i < (1 << n); i++)
        {
            int cur = 0;
            for (int j = 0; j < n; j++)
            {
                dp[j][0] = (i >> j) & 1;
                if (matrix[j][0] != dp[j][0])
                    cur++;
            }
            for (int j = 1; j < m; j++)
            {
                dp[0][j] = matrix[0][j];
                dp[1][j] = matrix[1][j];
                dp[2][j] = matrix[2][j];
                int res1 = dp[0][j] + dp[1][j] + dp[0][j - 1] + dp[1][j - 1];
                if (n == 3)
                {
                    int res2 = dp[1][j] + dp[2][j] + dp[1][j - 1] + dp[2][j - 1];
                    if ((res1 & 1) && (res2 & 1))
                        continue;
                    if (res1 & 1)
                        dp[2][j] ^= 1, cur++;
                    else if (res2 & 1)
                        dp[0][j] ^= 1, cur++;
                    else
                        dp[1][j] ^= 1, cur++;
                }
                else
                {
                    if (!(res1 & 1))
                        dp[0][j] ^= 1, cur++;
                }
            }
            ans = min(cur, ans);
        }
        cout << ans << endl;
    }
    // }
}
btc_runes
关注
专栏目录
Codeforces Round #663 (Div. 2) A-D 题解
lemonaaaaa的博客
08-10 381
图片好像挂了，不过都是题面，晚上修复 A. Suborrays 题目链接 题目原文 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qsnL4Fyp-1597031714049)(https://cdn.jsdelivr.net/gh/lemonaaaaa/CDN/img/codeforces/problems/1391A.jpg)] 题目大意 如果存在一个排列，对于其任意的连续子序列pi…pjp_i \dots p_jpi​…pj​都满足pi  OR  pi+1  OR 
Codeforces Round #684 (Div. 2) A - C2 题解
avgstuBoboge的博客
11-18 1024
Codeforces Round #684 (Div. 2) A - C2 题解 A Buy the String 题意 给定一个长度为 nnn 的01串，你可以用 hhh 的代价把字符串中任意一个字符取反，最终你要把这个01串买下来，0的单价为c0c_0c0​，1的单价为 c1c_1c1​。现给你n,h,c0,c1n,h,c_0,c_1n,h,c0​,c1​以及一个01串，问你最少花多少可以买下这个串。输出最小总价。 思路 贪心，设c0<c1c_0 \lt c_1c0​<c1​，若c1−c0
Codeforces Round #663 (Div. 2)
热门推荐
邵光亮的博客
08-11 13万+
A. Suborrays 题意： 输入一个长度 nnn，用 1n1 n1n 的数字进行随机排列。定义对于一个正整数 nnn，如果对于每一对 iii 和 j(1≤i≤j≤n)j(1≤i≤j≤n)j(1≤i≤j≤n) 都满足，对于 ppp 的每个子数组，其中所有元素的 OROROR 不小于该子数列中元素的个数。我们称长度为 nnn 的排列 ppp 是好的。 两个数进行位运算了，且范围是 1 n1~n1 n，那么进行位运算后的结果不会小于元素的个数。简而言之就是：无论怎么输出这个置换序列都是
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #833 (Div. 2) 思路
m0_75212691的博客
11-22 310
Codeforces Round #833 (Div. 2) 思路
Codeforces Round #829 (Div. 2)部分题解A B C1 E
weixin_63927680的博客
10-24 956
​Codeforces Round #829 (Div. 2)部分题解A B C1 E 原题地址：Dashboard - Codeforces Round #829 (Div. 2) - Codeforces A. Technical Support 题意： 有一个只包含“Q”和"A"的字符串，Q代表问题，A代表回答，有问必有答，也就是Q后面一定有n个A（n>=0） B. Kevin and Permutation 题意： 给定 ​
Codeforces Round #726 (Div. 2)题解A-E1
Arctic_Clam的博客
06-19 542
A. Arithmetic Array 分析： 当sum大于n时，那么添加（sum-n）个0，当sum小于n时，只需要添加一个数即可。 #include <iostream> using namespace std; int main() { int t; cin >> t; while(t--) { int n; cin >> n; int sum = 0; for(int i = 0; i &l
Codeforces Round #663 (Div. 2)A-D题解
StandNotAlone的博客
08-10 1348
Codeforces Round #663 (Div. 2)A-D题解 //写于大号rating值2184/2184，小号rating值1887/1887 //大号打星，本场小号打的，排名890，rating值+6 //本场19分钟切完ABC后，分析出了D的第一层结论后，脑抽得认为剩余情况最多是个3 ×\times× 3的矩阵 //暴力枚举了一波白给了一发re //发现自己想错了重构一遍代码后回归了正确的dp思路，但是此时心态开始变得急躁了起来 //对输入数据的预处理做得非常糟糕，强行分成四种情况if…el
Codeforces Round #663 (Div. 2)比赛中做出的三题
woshixuxiran的博客
08-10 732
题意场 萌新认识到了手速的可怕。 c题有一个坑，ab又怂担心不是真的水题，这场真的打炸了。 A. Suborrays 传送门：https://codeforces.ml/contest/1391/problem/A 题意：给你一个n，让你写出一个n的排列，要求任意选一段长度，长度内的数按位或运算大于等于这个长度。 解法：似乎你怎么输出这个排列都可以，只要这真的是个排列 代码： #include<bits/stdc++.h> using namespace std; typede
Codeforces Round #663 (Div. 2) 部分题解
Runewrz的博客
08-22 463
C. Cyclic Permutations 题意 给定一个大小为nnn的排列{ai}\{a_i\}{ai​}，按照以下方式建图： 对于每个满足1≤i≤n1 \leq i \leq n1≤i≤n的iii，找到最大的jjj，使得其满足1≤j<i1 \leq j < i1≤j<i和aj>aia_j>a_iaj​>ai​，连一条无向边(i,j)(i,j)(i,j)。 对于每个满足1≤i≤n1 \leq i \leq n1≤i≤n的iii，找到最小的jjj，使得其满足i<
Codeforces Round #663 (Div. 2) A~D
wait
08-11 267
目录 A. Suborrays（思维） B. Fix You（思维） C. Cyclic Permutations（思维，排列组合） D. 505（DP，前缀和） A. Suborrays（思维） 思路： 线性输出就行了； #include <bits/stdc++.h> using namespace std; int a[100010]; int main() { int t; cin >>t; while(t--) { int n; ...
Codeforces Round #663 (Div. 2) A. Suborrays
ACkingdom的博客
08-10 243
题目链接 思路： 倒序输出n-1即可。 代码： #include<bits/stdc++.h> #define int long long #define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); const int N=1e5+3; const int M=2e4+5; const double eps=1e-8; const int mod=998244353; const int inf=0x7fffffff; cons
Codeforces Round #663 (Div. 2) C. Cyclic Permutations
张小生的先生的博客
08-11 347
题目链接：C. Cyclic Permutations 题意 给你一个数n，让你寻找1～n的全排列中满足以下条件的排列有多少种。 一个排列中，我们可以将一个数左边第一个大于它的数的序号和该数序号连接，也可以将右边第一个大于它的数的序号和该数连接，如果没有这种数就不连接。对每个数操作完后，形成一个无向图，如果无向图有环则满足条件，无环则不满足。 题解 首先通过分析我们可以知道当1在中间时必满足条件。 以a、1、b为例，设1的序号为x，则a的序号为x-1，b的序号为x+1。 可知（x,x+1）和（x,x-1）这
Codeforces Round #663 (Div. 2) C. Cyclic Permutations(思维)
一只谜谜怪的博客
08-10 872
题目链接：传送门 思路：可以先算无环的情况数，再用全部情况数减，算无环情况的关键点有两个： 1）除了最大数n以外，每个数一定至少有一条边指向另一个数，当每个数只有一条边连出去时（共n-1条边），图是无环的，即只要有一个数连两条边出去就有环。 2）对于特定的数i (i < n - 1 )，要保证无环，它两边的数已经被确定了，一边必须是(1) — (i - 1) ， 一边是 (i+1) — (n),即只要对于前n-1个数，满足一边都是小于它的数，一边全大于，即可保证无环，其他情况均有环(因为会发出两条边
codeforces round #772 (div. 2)
最新发布
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值