Codeforces Round #344 (Div. 2)

最新推荐文章于 2021-07-21 18:49:34 发布
最新推荐文章于 2021-07-21 18:49:34 发布
阅读量373 收藏
点赞数
分类专栏： online judge Codeforces 其他 贪心 其他---------------------------- 其他 单调队列 字符串 kmp和扩展kmp 字符串-------------------------- 动态规划----------------------- 动态规划 斜率优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fsss_7/article/details/50811199
版权

链接：http://codeforces.com/contest/631

problemA：给定两个数组A,B。设f(x,l,r)=x[l]|x[l+1]...|x[r]，求max(f(A,l,r)+f(B,l,r))。

分析：因为是取或是贪心变大，所以我们把整个数组或起来即可，即l==1&&r==n。O(n)

代码：

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<math.h>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N=1010;
const int MAX=151;
const int MOD1=1000007;
const int MOD2=100000009;
const double EPS=0.00000001;
typedef long long ll;
const ll MOD=1000000007;
const ll INF=10000000010;
typedef unsigned long long ull;
int a[N],b[N];
int main()
{
    int i,n,x=0,y=0;
    scanf("%d", &n);
    for (i=1;i<=n;i++) {
        scanf("%d", &a[i]);x|=a[i];
    }
    for (i=1;i<=n;i++) {
        scanf("%d", &b[i]);y|=b[i];
    }
    printf("%d\n", x+y);
    return 0;
}

problemB：给定n,m,k，在一个初始全为0的n*m矩阵中进行k次操作，操作一：将第ri行变为颜色ai，操作二：将第ci列变为颜色ai。输出这个矩阵最后的样子。

分析：用两个数组分别记录行和列的最后颜色即可，最后打印的时候比较下行列的先后即可。O(n*m+k)

代码：

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<math.h>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N=5010;
const int MAX=151;
const int MOD1=1000007;
const int MOD2=100000009;
const double EPS=0.00000001;
typedef long long ll;
const ll MOD=1000000007;
const ll INF=10000000010;
typedef unsigned long long ull;
struct node {
    int time,co;
}r[N],c[N];
int main()
{
    int i,j,n,m,k,x,y,z;
    scanf("%d%d%d", &n, &m, &k);
    memset(r,0,sizeof(r));
    memset(c,0,sizeof(c));
    for (i=1;i<=k;i++) {
        scanf("%d%d%d", &x, &y, &z);
        if (x==1) { r[y].time=i;r[y].co=z; }
        else { c[y].time=i;c[y].co=z; }
    }
    for (i=1;i<=n;i++) {
        for (j=1;j<=m;j++)
        if (r[i].time>c[j].time) printf("%d ", r[i].co);
        else printf("%d ", c[j].co);
        printf("\n");
    }
    return 0;
}


problemC：给定n,m，一个长度为n的a数组，m次操作，每次操作有t,r：t==1将a[1]~a[r]排为升序，t==2将a[1]~a[r]排为降序。求m次操作之后的a数组。

分析：首先很明显如果后面有一个操作ri>现在的操作rj，那么现在的操作rj是无意义的，那么我们就可以将r操作用单调队列删除掉一些无意义的数据，那么剩下的r操作一定是降序的。那么我们先将a[1]~a[max(r)]排序，然后每次处理a[r(i-1)]~a[ri]即可，这时只要根据ti选择从排好序的数组里从左边取数或者从右边取数就好了。O(nlogn)

代码：

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<math.h>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N=200010;
const int MAX=151;
const int MOD1=1000007;
const int MOD2=100000009;
const double EPS=0.00000001;
typedef long long ll;
const ll MOD=1000000007;
const ll INF=10000000010;
typedef unsigned long long ull;
struct node {
    int t,r;
}b[N];
int a[N],ans[N];
int main()
{
    int i,j,n,m,x,y,k=0,L,R;
    scanf("%d%d", &n, &m);
    for (i=1;i<=n;i++) {
        scanf("%d", &a[i]);ans[i]=a[i];
    }
    for (i=1;i<=m;i++) {
        scanf("%d%d", &x, &y);
        while (k>0&&(y>=b[k].r)) k--;
        if (k==0||x!=b[k].t) { k++;b[k].t=x;b[k].r=y; }
    }
    L=1;R=b[1].r;
    sort(a+1,a+b[1].r+1);
    for (i=1;i<k;i++) {
        for (j=b[i].r;j>b[i+1].r;j--)
        if (b[i].t==1) { ans[j]=a[R];R--; }
        else { ans[j]=a[L];L++; }
    }
    for (i=b[k].r;i>0;i--)
    if (b[k].t==1) { ans[i]=a[R];R--; }
    else { ans[i]=a[L];L++; }
    for (i=1;i<=n;i++) printf("%d ", ans[i]);
    printf("\n");
    return 0;
}

problemD：给定n,m，然后两行表示两个字符串t,s，{3-a 2-b 3-x}=="aaabbxxx"。求s在t中出现过多少次。

分析：首先我们先解决字符串表示不唯一的问题，即"aaa"可以为{3-a}或{2-a 1-a}或{1-a 2-a}，我们将所有相邻的相同字符压缩在一起，这样对题目求解是无影响的。然后我的方法是先对s的表示长度讨论，如果lens==1||lens==2，那么我们for一遍就可以了，当lens>2时，去掉s的首尾两个表示字符将中间的去与t跑kmp，然后O(n)判一遍就行了。。PS：请忽视代码中将数字和字符合在一起离散化的傻逼操作。。正确做法应该是将kmp改成两个关键字的就行了。

代码：

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<math.h>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N=200010;
const int MAX=151;
const int MOD1=1000007;
const int MOD2=100000009;
const double EPS=0.00000001;
typedef long long ll;
const ll MOD=1000000007;
const ll INF=10000000010;
typedef unsigned long long ull;
int n,m,len1,len2;
ll x[N],y[N];
string S;
char s[N][3],t[N][3];
map<string,int>ma;
int f[N],h[N];
string getS(int x) {
    string ret="";
    while (x) {
        ret=(char)(x%10+'0')+ret;x/=10;
    }
    return ret;
}
int q[N],nex[N];
void pre_kmp(int s[],int les)
{
    int i,k;
    nex[0]=-1;k=-1;
    for (i=0;i<les;i++)  {
        while (k>-1&&s[k]!=s[i]) k=nex[k];
        k++;nex[i+1]=k;
    }
}
void kmp(int s[],int t[],int les,int let)
{
    pre_kmp(s,les);
    int i,k=0,bo=0;
    memset(q,0,sizeof(q));
    for (i=0;i<let;i++) {
        while (k>0&&s[k]!=t[i]) k=nex[k];
        if (s[k]==t[i])  k++;
        if (k==les) {
            q[i]=1;k=nex[k];
        }
    }
}
ll solve() {
    ll ret=0;
    int i,w,k=0,L,R;
    for (i=1;i<=len1;i++) {
        S=getS(x[i]);S+=s[i][1];
        w=ma[S];
        if (w) f[i-1]=w;
        else { k++;ma[S]=k;f[i-1]=k; }
    }
    for (i=2;i<len2;i++) {
        S=getS(y[i]);S+=t[i][1];
        w=ma[S];
        if (w) h[i-2]=w;
        else { k++;ma[S]=k;h[i-2]=k; }
    }
    kmp(h,f,len2-2,len1);
    for (i=len2-2;i<len1-1;i++)
    if (q[i]) {
        L=i-(len2-2)+1;R=i+2;
        if (s[L][1]==t[1][1]&&x[L]>=y[1]&&s[R][1]==t[len2][1]&&x[R]>=y[len2]) ret++;
    }
    return ret;
}
int main()
{
    ll ans=0;
    scanf("%d%d", &n, &m);
    len1=len2=0;
    for (int i=1;i<=n;i++) {
        scanf("%I64d%s", &x[i], s[i]);
        if (len1>0&&s[i][1]==s[len1][1]) { x[len1]+=x[i]; }
        else { len1++;x[len1]=x[i];s[len1][1]=s[i][1]; }
    }
    for (int i=1;i<=m;i++) {
        scanf("%I64d%s", &y[i], t[i]);
        if (len2>0&&t[i][1]==t[len2][1]) { y[len2]+=y[i]; }
        else { len2++;y[len2]=y[i];t[len2][1]=t[i][1]; }
    }
    if (len2==1) {
        for (int i=1;i<=len1;i++)
        if (s[i][1]==t[1][1]&&x[i]>=y[1]) ans+=x[i]-y[1]+1;
    } else if (len2==2) {
            for (int i=1;i<len1;i++)
            if (s[i][1]==t[1][1]&&s[i+1][1]==t[2][1]&&x[i]>=y[1]&&x[i+1]>=y[2]) ans++;
        } else ans=solve();
    printf("%I64d\n", ans);
    return 0;
}

problemE：给定一个数组a，定义一个数组的价值为sum=sigma(1~n)a[i]*i。现在允许一次操作：取出数组中一个数，然后插入到任意位置。求一次操作后的最大价值。

分析：很明显有3中情况，1：所有元素不动。2：选出的那个数向前找一个位置插入。3：选出的那个数向后插入。我们来讨论向前插入的那种情况(向后同理)，对于每一个a[i]都是可能被选中的，那么对于每一个a[i]就会对应有一个a[j]有a[j]a[j+1]...a[i]=>a[i]a[j]a[j+1]...a[i-1]是使得原价值ans获得最大收益的，即我们要快速找到max(a[i]*(j-i)+sum[i-1]-sum[j-1])=>max(a[i]*j   -sum[j-1]   +sum[i-1]-a[i]*i)，那么有sum[i-1]-a[i]*i是不变的，我们将j当成斜率，-sum[j-1]当成截距，然后我们只要将1~i-1形成的i-1条直线维护一个下凸包，那么对于i来说我们就可以三分快速找到那个最优的j了。最后将ans+mx就是啦。

代码：

#include<map>
#include<set>
#include<cmath>
#include<queue>
#include<math.h>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int N=200010;
const int MAX=151;
const int MOD1=100000007;
const int MOD2=100000009;
const double EPS=0.00000001;
typedef long long ll;
const ll INF=10000000010;
const ll MOD=1000000007;
typedef unsigned long long ull;
struct node {
    ll l,tot;
}d[N];
int k;
ll a[N],sum[N];
ll calal(int x,int r) {
    return a[x]*d[r].l-sum[d[r].l-1]+sum[x-1]-a[x]*x;
}
ll getchangel(int x) {
    if (!k) return 0;
    int l=0,r=k,mid=k/2;
    while (l+1<r)
    if (calal(x,mid)<calal(x,mid+1)) { l=mid;mid=(l+r)/2; }
    else { r=mid;mid=(l+r)/2; }
    return calal(x,r);
}
void addl(ll l,ll tot) {
    while (k>1&&(d[k].tot-d[k-1].tot)*(d[k-1].l-l)>=(tot-d[k-1].tot)*(d[k-1].l-d[k].l)) k--;
    k++;d[k].l=l;d[k].tot=tot;
}
ll calar(int x,int r) {
    return a[x]*d[r].l-sum[d[r].l]+sum[x]-a[x]*x;
}
ll getchanger(int x) {
    if (!k) return 0;
    int l=1,r=k+1,mid=k/2;
    while (l+1<r)
    if (calar(x,mid-1)<calar(x,mid)) { l=mid;mid=(l+r)/2; }
    else { r=mid;mid=(l+r)/2; }
    return calar(x,l);
}
void addr(ll l,ll tot) {
    while (k>1&&(d[k].tot-d[k-1].tot)*(d[k-1].l-l)<=(tot-d[k-1].tot)*(d[k-1].l-d[k].l)) k--;
    k++;d[k].l=l;d[k].tot=tot;
}
int main()
{
    int i,n;
    ll ans=0,mx=0;
    scanf("%d", &n);
    for (i=1;i<=n;i++) scanf("%I64d", &a[i]);
    sum[0]=0;k=0;
    for (i=1;i<=n;i++) {
        ans+=(ll)a[i]*i;sum[i]=sum[i-1]+a[i];
    }
    for (i=1;i<=n;i++) {
        mx=max(mx,getchangel(i));
        addl(i,-sum[i-1]);
    }
    k=0;
    for (i=n;i>0;i--) {
        mx=max(mx,getchanger(i));
        addr(i,-sum[i]);
    }
    printf("%I64d\n", ans+mx);
    return 0;
}


Fsss_7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #344 (Div. 2) C 题题解 （贪心+单调栈）
【落~风~月】
03-05 803
C. Report time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Each month Blake gets the report containing main
数字矩阵
qcy的博客
07-21 727
数字矩阵 本题出自cf中，我第一眼看到这一题，我脑子里想完了，情况也太多了，后来看了y总的视频发现这道题就是：让你判断你输入的数中有几个负数，以及去找出其中绝对值最小的数，因为两个负数总可以通过一条折线连接起来，去改变这两个负数的值而保持这条折线中的其它数的符号不变（因为我们可以发现这条折线中的其他数总会改变两次符号，也即符号不变），以此为思路，我们解题代码如下。 给定一个 n×m 的整数矩阵，其中第 i 行第 j 列的元素为 aij。 你可以进行任意多次如下操作： 选择矩阵中的两个相邻元素，将它们均乘以
codeforces Round #344 A~E
w20810的专栏
03-19 530
A. Interview 题意：给定n（n 分析：暴力枚举区间就行了。 代码： #include using namespace std; typedef long long LL; typedef unsigned long long ULL; const LL INF = 1e9+7; const LL MINT = ~0u>>1; #define lson l,m,rt<<1
Codeforces Round #344 (Div. 2) D. Messenger （kmp）
a670531899的博客
08-09 141
题目 http://codeforces.com/contest/631/problem/D 题意 给你一个压缩的主串和一个压缩的模式串，压缩方式为分块压缩，相同且相邻的字母压缩到一个块里，用x-c表示（x表示个数，c表示字母）。问模式串在主串中出现了多少次。 思路 和普通的kmp差不多，把每个x-c当成一个字母，再用kmp进行匹配。 和普通字符串的匹配不同的是：如果模式串两边的块要比...
Codeforces Round #344 (Div. 2) C. Report（思维好题）
qq_42479630的博客
03-19 151
题目链接 题意：给出n个无序的数以及m个操作，每个操作由两个数组成，第一个数是操作的方式，第二个数 i 是操作的范围，若第一个数是1，则给 1-i 个数按升序排序，若第二个数是2，则给 1-i 个数按降序排列。输出所有操作完成后的序列。 思路：一开始写的时候并没有啥思路，看了大佬们的题解才会的，真的是神乎奇迹。。。 首先，我们是可以利用栈来缩小我们的操作次数的，比如先给前3个数升序，再把前4个...
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
Codeforces Round #344 (Div. 2) 解题报告
Linoy
03-04 1073
Codeforces Round #344 (Div. 2)
Codeforces Round #344 (Div. 2) D. Messenger
_zidaoziyan的博客
03-21 403
D. Messenger time limit per test 2 seconds memory limit per test 512 megabytes input standard input output standard output Each employee of the "Blake Techologies" compa
Codeforces Round #344 (Div. 2) E. Product Sum （三分）
LzyRapX
09-06 628
E. Product Sum time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Blake is the boss of Kris, however, this does
Codeforces Round #344 (Div. 2)C. Report
走一步再走一步
08-15 461
C. Report time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Each month Blake gets the report containing main
Codeforces Round #344 (Div. 2) C. Report
Ezereal的博客
09-06 236
题意: 给你一个长度为n的初始的序列和q个操作((1 ≤ n,q ≤ 200000),一个操作包括ti和ri,ti为1表示从小到大,ti为2表示从大到小,ri表示对前面多少个进行排序。   思路:如果后面的操作长度比前面的长度要大,那么可以知道前面的操作便是无效的,那么如果前面的操作是有效的话,他比后面操作最大的序列长度要大,那么他比后面的最大的序列长度大的那一部分便可以直接确定
Codeforces Round #367 (Div. 2)E. Working routine
热门推荐
Fsss
08-12 2万+
链接：http://codeforces.com/contest/706/problem/E 题意：给定一个n*m的矩阵，给定q次剪切交换，每次给出a,b,c,d,h,w表示将左上角为(a,b)和左上角为(c,d)的高h宽w的矩阵交换，保证两个矩形不重叠没有公共边。 分析：对每个格子建一个十字链表，每次剪切的时候我们只需要将周围的那些链表交换即可。O(q*(n+m)) 代码： #inclu
bzoj2286: [Sdoi2011消耗战
Fsss
04-07 1845
链接：http://www.lydsy.com/JudgeOnline/problem.php?id=2286 题意：中文题。 分析：题目中要求所有的关键点与根1断开，很容易想到树形dp。但是由于多组询问会导致时间*m。单次O(n)不可取。很显然是要优化的，我们发现单次O(n)时还是会做很多无用功，而且题目说sigma(ki) 代码： #include #include #include
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级别更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值