【AtCoder】ARC066

最新推荐文章于 2024-11-13 21:40:45 发布
最新推荐文章于 2024-11-13 21:40:45 发布
阅读量122 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ivorysi/p/10855532.html
版权

ARC066

C - Lining Up

判断是否合法即可，合法是\(2^{\lfloor \frac{N}{2}\rfloor}\)

不合法就是0

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 200005
//#define ivorysi
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;T f = 1;char c = getchar();
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 +c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
const int MOD = 1000000007;
int N;
int cnt[MAXN];
int inc(int a,int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}
int mul(int a,int b) {
    return 1LL * a * b % MOD;
}
int fpow(int x,int c) {
    int res = 1,t = x;
    while(c) {
    if(c & 1) res = mul(res,t);
    t = mul(t,t);
    c >>= 1;
    }
    return res;
}
void Solve() {
    read(N);
    int a;
    for(int i = 1 ; i <= N ; ++i) {
    read(a);cnt[a]++;
    }
    if(N & 1) {
    if(cnt[0] != 1) {puts("0");return;}
    }
    for(int i = N - 1 ; i >= 1 ; i -= 2) {
    if(cnt[i] != 2) {
        puts("0");return;
    }
    }
    out(fpow(2,N / 2));enter;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

D - Xor Sum

按位dp，每一位的两个数要么就是1 1，要么就是1 0（不分顺序），要么就是0 0

可以发现，这三种情况如果有一位上是不同的，那算出来的是不同的u和v

然后我们可以限制两个数的和每一位是多少来dp，因为和肯定大于异或和

设\(dp[i][0 / 1][0/1]\)表示前i位，和有没有碰到上界，前面的和需不需要进位

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 200005
//#define ivorysi
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;T f = 1;char c = getchar();
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 +c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
const int MOD = 1000000007;
int64 N;
int dp[65][2][2];
int inc(int a,int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}
int mul(int a,int b) {
    return 1LL * a * b % MOD;
}
void update(int &x,int y) {
    x = inc(x,y);
}
void Solve() {
    read(N);
    dp[61][1][0] = 1;
    for(int i = 60 ; i >= 0 ; --i) {
    for(int j = 0 ; j < 2 ; ++j) {
        for(int k = 0 ; k < 2 ; ++k) {
        int t = (N >> i) & 1,u;
        u = t;
        if(j == 0) u = 1;
        
        for(int h = 0 ; h <= u ; ++h) {
            int p = j && (h == t);
            if(k) {
            if(h == 0){
                update(dp[i][p][1],dp[i + 1][j][k]);
                update(dp[i][p][0],dp[i + 1][j][k]);
            }
            else {
                update(dp[i][p][1],dp[i + 1][j][k]);
            }
            }
            else {
            if(h == 0) {
                update(dp[i][p][0],dp[i + 1][j][k]);
            }
            else {
                update(dp[i][p][1],dp[i + 1][j][k]);
                update(dp[i][p][0],dp[i + 1][j][k]);
            }
            }
        }
        }
    }
    }
    int ans = 0;
    for(int j = 0 ; j < 2 ; ++j) {
    update(ans,dp[0][j][0]);
    }
    out(ans);enter;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

E - Addition and Subtraction Hard

发现括号嵌套超过三个总可以改成嵌套两个

然后我们就可以设\(dp[i][j]\)表示第i位之前有j个没闭合的括号，有一个括号符号改变一次正反，我们只能在初始符号是减号的地方加括号，因为加号的后面加括号没什么用

#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 100005
//#define ivorysi
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
    res = 0;T f = 1;char c = getchar();
    while(c < '0' || c > '9') {
    if(c == '-') f = -1;
    c = getchar();
    }
    while(c >= '0' && c <= '9') {
    res = res * 10 +c - '0';
    c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
    out(x / 10);
    }
    putchar('0' + x % 10);
}
int N;
int64 dp[MAXN][3];
int64 A[MAXN];
char op[MAXN][5];
void update(int64 &x,int64 y) {
    x = max(x,y);
}
void Solve() {
    read(N);
    for(int i = 1 ; i <= N ; ++i) {
    read(A[i]);
    if(i != N) scanf("%s",op[i] + 1);
    }
    dp[1][0] = A[1];
    dp[1][1] = -1e18;
    dp[1][2] = -1e18;
    for(int i = 2 ; i <= N ; ++i) {
    for(int j = 0 ; j < 3 ; ++j) dp[i][j] = -1e18;
    for(int j = 0 ; j < 3 ; ++j) {
        int t = (op[i - 1][1] == '-');
        int k = (t ^ j) & 1;
        int64 d = A[i];
        if(k) d = -A[i];
        if(t && j < 2) update(dp[i][j + 1],dp[i - 1][j] + d);
        for(int h = 0 ; h <= j ; ++h) update(dp[i][h],dp[i - 1][j] + d);
    }
    }
    out(dp[N][0]);enter;
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

F - Contest with Drinks Hard

(之前的题解)

我写的斜率维护，放弃了我最擅长的叉积维护，然后发现叉积维护也不会爆long long哦……

一写斜率维护我的代码就会莫名变长而且难写……行吧

我们看这题

推了推式子，发现这是个斜率的式子，但是斜率单增还要求最大值？啥我又得二分凸包……好烦……

然后我们求一个pre[x]表示[1,x]的最大分数，和一个suf[x]表示[x,N]里的最大分数

然后对于一个点枚举一个包含它的区间，计算取值

显然超时

那就放在分治上，左端点在左区间，右端点在右区间，把最大值处理成前后缀max，两边都是斜率优化

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#define fi first
#define se second
#define pii pair<int,int>
//#define ivorysi
#define mp make_pair
#define pb push_back
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 300005
using namespace std;
typedef long long int64;
typedef double db;
typedef unsigned int u32;
template<class T>
void read(T &res) {
    res = 0;T f = 1;char c = getchar();
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9' ) {
        res = res * 10 + c - '0';
        c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {x = -x;putchar('-');}
    if(x >= 10) {
        out(x / 10);
    }
    putchar('0' + x % 10);
}
int N,M;
int64 T[MAXN],pre[MAXN],suf[MAXN],sum[MAXN],ans[MAXN],cal[MAXN];
struct Point {
    int64 x,y;
    Point(){}
    Point(int64 _x,int64 _y) {
        x = _x;y = _y;
    }
}que[MAXN],pre_pos[MAXN],suf_pos[MAXN];
struct qry_node {
    int id,pos;
    int64 v;
}qry[MAXN],tmp1[MAXN],tmp2[MAXN];
bool slope(Point a,Point b,Point c) {
    return (c.y - b.y) * (b.x - a.x) > (b.y - a.y) *  (c.x - b.x);
}
void DC(int l,int r,int ql,int qr) {
    if(qr < ql) return;
    if(l == r) return;
    int mid = (l + r) >> 1;
    int tot = 0;
    que[++tot] = pre_pos[l - 1];
    for(int i = l ; i <= mid ; ++i) {
        while(tot > 1) {
            if(slope(que[tot - 1],que[tot],pre_pos[i])) --tot;
            else break;
        }
        que[++tot] = pre_pos[i];
    }
    for(int i = r + 1 ; i >= mid + 2; --i) {
        int L = 1,R = tot;
        while(L < R) {
            int mid = (L + R) >> 1;
            if((que[mid + 1].y - que[mid].y) >= 1LL * i * (que[mid + 1].x - que[mid].x)) 
                L = mid + 1;
            else R = mid;
        }
        L = que[L].x;
        cal[i] = suf[i] + pre[L] - sum[i - 1] + sum[L] + 1LL * (i - L - 1) * (i - L) / 2;
    }
    tot = 0;
    que[++tot] = suf_pos[r + 1];
    for(int i = r ; i > mid ; --i) {
        while(tot > 1) {
            if(slope(suf_pos[i],que[tot],que[tot - 1])) --tot;
            else break;
        }
        que[++tot] = suf_pos[i];
    }
    for(int i = l - 1 ; i < mid ; ++i) {
        int L = 1,R = tot;
        while(L < R) {
            int mid = (L + R) >> 1;
            if((que[mid].y - que[mid + 1].y) >= 1LL * i * (que[mid].x - que[mid + 1].x))
                R = mid;
            else L = mid + 1;
        }
        L = que[L].x;
        cal[i] = pre[i] + suf[L] - sum[L - 1] + sum[i] + 1LL * (L - i - 1) * (L - i) / 2;
    }
    for(int i = l ; i < mid ; ++i) cal[i] = max(cal[i - 1],cal[i]);
    for(int i = r ; i > mid + 1 ; --i) cal[i] = max(cal[i + 1],cal[i]);
    int t1 = 0,t2 = 0;
    for(int i = ql ; i <= qr ; ++i) {
        if(qry[i].pos <= mid) {
            ans[qry[i].id] = max(ans[qry[i].id],cal[qry[i].pos - 1] + T[qry[i].pos] - qry[i].v);
            tmp1[++t1] = qry[i];
        }
        else {
            ans[qry[i].id] = max(ans[qry[i].id],cal[qry[i].pos + 1] + T[qry[i].pos] - qry[i].v);
            tmp2[++t2] = qry[i];
        }
    }
    int p = ql - 1;
    for(int i = 1 ; i <= t1 ; ++i) qry[++p] = tmp1[i];
    for(int i = 1 ; i <= t2 ; ++i) qry[++p] = tmp2[i];
    DC(l,mid,ql,ql + t1 - 1);
    DC(mid + 1,r,ql + t1,qr);
}   

void Solve() {
    read(N);
    for(int i = 1 ; i <= N ; ++i) read(T[i]);
    for(int i = 1 ; i <= N ; ++i) sum[i] = sum[i - 1] + T[i];
    int tot = 0;
    que[++tot] = Point(0,0);
    for(int i = 1 ; i <= N ; ++i) {
        int l = 1,r = tot;
        while(l < r) {
            int mid = (l + r) >> 1;
            if((que[mid + 1].y - que[mid].y) >= 1LL * i * (que[mid + 1].x - que[mid].x)) 
                l = mid + 1;
            else r = mid;
        }
        l = que[l].x;
        pre[i] = pre[l] + 1LL * (i - l) * (i - l + 1) / 2 - sum[i] + sum[l];
        pre[i] = max(pre[i],pre[i - 1]);
        Point p = Point(i,pre[i] + sum[i] + (1LL * i * (i - 1)) / 2);
        while(tot > 1) {
            if(slope(que[tot - 1],que[tot],p)) --tot;
            else break;
        }
        que[++tot] = p;
    }
    tot = 0;
    que[++tot] = Point(N + 1,(1LL * (N + 1) * (N + 2) / 2) - sum[N]);
    for(int i = N ; i >= 1 ; --i) {
        int l = 1,r = tot;
        while(l < r) {
            int mid = (l + r) >> 1;
            if((que[mid].y - que[mid + 1].y) >= 1LL * i * (que[mid].x - que[mid + 1].x))
                r = mid;
            else l = mid + 1;
        }
        l = que[l].x;
        suf[i] = suf[l] + (1LL * (l - i + 1) * (l - i) / 2) - sum[l - 1] + sum[i - 1];
        suf[i] = max(suf[i],suf[i + 1]);
        Point p = Point(i,suf[i] - sum[i - 1] + (1LL * i * (i + 1) / 2));
        while(tot > 1) {
            if(slope(p,que[tot],que[tot - 1])) --tot;
            else break;
        }
        que[++tot] = p;
    }
    for(int i = 0 ; i <= N ; ++i) {
        pre_pos[i] = Point(i,pre[i] + sum[i] + (1LL * i * (i + 1) / 2));
    }
    for(int i = 1 ; i <= N + 1 ; ++i) {
        suf_pos[i] = Point(i,suf[i] - sum[i - 1] + (1LL * i * (i - 1) / 2));
    }
    read(M);
    int p;int64 v;
    for(int i = 1 ; i <= M ; ++i) {
        read(p);read(v);
        qry[i] = (qry_node){i,p,v};
        ans[i] = pre[p - 1] + suf[p + 1];
    }
    DC(1,N,1,M);
    for(int i = 1 ; i <= M ; ++i) {
        out(ans[i]);enter;
    }
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Solve();
    return 0;
}

转载于:https://www.cnblogs.com/ivorysi/p/10855532.html

weixin_30449453
关注
Atcoder arc096E
mayaohua
12-10 523
显然考虑容斥，求出钦定前kkk种调料最终使用不超过111次的方案数F[k]F[k]F[k]即可。 考虑如何求出FFF。对于一个方案，我们可以考虑其中所有使用了这kkk种调料中某几种的拉面，那么它们显然将这kkk种调料中用了一次的调料分为了若干个非空集合，不妨设分成了ccc个集合，枚举用了一次的调料数目，可知对应的方案数为∑i=ck(ki)⋅s(i,c)⋅22n−k⋅2c⋅(n−k)\sum_{i=...
【容斥原理】【树形DP】Atcoder ARC101 Ribbons on Tree
氧化钠的博客
08-27 959
分析： 很不错的树形DP+容斥原理的混合题 不得不说，尽管Atcoder去世了一个半月，但这次题目质量仍然保持得很不错 首先，这题可以运用容斥原理转化一下：定义EEE为给出的边集，设F⊆EF⊆EF\subseteq E，f(F)f(F)f(F)表示：F中的边全部未被覆盖的方案数。 答案就是∑(−1)|F|f(F)∑(−1)|F|f(F)\sum (-1)^{|F|}f(F) 那么接下来就...
[arc066e]Addition and Subtraction Hard
不来也不去的一只失忆蝴蝶
11-16 976
题目大意一个表达式有+有-，添加一些括号最大化表达式的值。DP首先只会在-号前放左括号。 简单的想法是设f[i,j]表示做完前i个数字，目前还有j个左括号没有匹配右括号。 然后很难发现，j<=2才有意义。#include<cstdio> #include<algorithm> #define fo(i,a,b) for(i=a;i<=b;i++) using namespace std; typ
【Actoder Arc 066】C - Lining Up
ETO的博客
09-26 582
C - Lining Up Time limit : 2sec / Memory limit : 256MB Score : 300 points Problem Statement There are N people, conveniently numbered 1 through N. They were standing in a row yesterday, but now th...
atcoder arc066C (思维+dp)
摇摇乐的博客
11-18 373
题目链接 题意： 有 nnn 个数，每两个数之间有加号或者减号，要求在其中加入括号，使得最后的结果最大 思路： 主要是分析有两个性质，首先是在加号前面加括号没有意义，因为加号的括号脱去不改变符号，然后是最多加两重括号。三重括号可以转化为两重括号或者一重括号。有了这些性质，那么我们就可以令 dp[i][j]dp[i][j]dp[i][j] 表示到第 iii 个数左括号 −-− 右括号为 jjj 的最...
【贪心】ARC066E Addition and Subtraction Hard
氧化钠的博客
08-07 405
分析： 考场上看到一堆人写DP。。。。也许DP能过？ 其实。。。这题不就是个傻逼贪心嘛。。。。。 首先，由于这题括号能叠加，所以有一个很简单的结论： 整个式子最外层的1个括号最多只有一对。。。。。 首先，括号的左端点的符号必须为负才有意义，在这样的条件下，如果括号内还存在一个符号，那么后面的值都可以为正。因为可以从那个负号开始，把后面一堆的正号都放在一个小的括号里。 如上图所示 ...
[arc066f]Contest with Drinks Hard
不来也不去的一只失忆蝴蝶
11-16 1016
题目大意有一些物品，每个买了有代价。 如果存在一个极大区间[l,r]内的物品都被买了，这个区间长度为k，可以获得的收益是k*(k+1)/2。 现在若干次询问，每次问假如修改了某个物品的价格，最大收益是多少？DP先处理出L和R分别表示前缀dp值和后缀dp值，显然dp可以用决策单调性优化。 然后现在我们需要求出一定买某个物品的最大值，记为ans[]。 也就是说假设买了区间[l,r]，那么[l,r
Atcoder ARC103测试数据
10-12
本次提及的“Atcoder ARC103测试数据”是该平台举办的一场比赛——ARC103的练习或比赛用测试数据集。这些数据对于参赛者或希望学习算法和编程技巧的人来说具有很高的价值。 测试数据在编程竞赛中扮演着至关重要的...
Atcoder ARC102测试数据
10-12
日本竞赛网站Atcoder的ARC102场的测试数据，题面可以在Atcoder找到。
Atcoder arc102F
mayaohua
03-05 353
完全不会的神仙结论题。 我们称一次操作iii是将pi−1,pi,pi+1p_{i-1},p_i,p_{i+1}pi−1​,pi​,pi+1​翻转（pi−1>pi>pi+1p_{i-1}>p_i>p_{i+1}pi−1​>pi​>pi+1​）。 首先可以发现一个性质，如果我们做了操作iii，那么永远不可能再做操作i−1i-1i−1或i+1i+1i+1了。考虑反证，...
C - Lining Up（思维+快速幂）
qq_40859951的博客
05-27 391
Problem Statement There areNNpeople, conveniently numbered11throughNN. They were standing in a row yesterday, but now they are unsure of the order in which they were standing. However, each pers...
AtCoder Regular Contest 066--C - Lining Up--规律+快速幂
lanshan1111的博客
05-28 192
C - Lining Up Time Limit: 2 sec / Memory Limit: 256 MB Score : points Problem Statement There are people, conveniently numbered through . They were standing in a row yesterday, but now they are uns...
【AtCoder Regular Contest 066 F】【JZOJ 5451】Contest with Drinks Hard
LYD729
11-06 460
Decsription有一个长度为n的数列，对于每个位置，你可以选/不选，选第i个位置的代价为a[i] 假设c[i]=0/1表示第i个位置选/不选，那么最后的收益定义为： (∑ni=1∑nj=i(∏jk=ick))−(∑ni=1ciai)(\sum_{i=1}^n\sum_{j=i}^n(\prod_{k=i}^jc_k))-(\sum_{i=1}^nc_ia_i) 接下来有m个询问，形如x
ARC 066D Xor Sum
Freopen的博客
08-07 381
因为a xor b = a + b - 2 （a &amp; b） 从低位到高位用记忆化搜索实现数位DP #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;cctype&gt; #define LL long long #define mod 1000000007 #de...
[ARC066F]Contest with Drinks Hard
时光真疯狂, 我一路执迷于匆忙.
11-04 727
Description给出一个序列a，你需要求出一个0/1序列c，使得 ∑i=1n∑j=in∏k=ijCk−∑i=1nCiAi\sum_{i=1}^{n}\sum_{j=i}^{n}\prod_{k=i}^{j}Ck-\sum_{i=1}^{n}CiAi 最大 给出m次修改形如(x,y)，表示把a[x]改成y，每次修改之间独立，对于每次修改之后求出答案n,m<=3*1e5Solution首先一
动态规划习题其七【力扣】【算法学习day.29】
2301_79232523的博客
11-11 331
##我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
gbase8s数据库常见的连接算法
最新发布
wangyx01的博客
11-13 177
外表指针指向第一条数据，内表指针顺序移动，找到和外表匹配项，记录，内表循环结束后外边指针继续向下移动，一直到外表循环结束为止。hash 连接中只有极少量的随机读，大部分都为顺序读，极大缓解了大量随机读的压力。有则取捅中进行匹配（若捅中有多条数据则发生hash碰撞），没有则继续匹配下一。hash 连接避免了嵌套循环的大量的随机读，简单伪代码如下。在gbase8s 中 ，常见的连接算法主要分为如下几种。细分可分为索引嵌套循环，块嵌套循环，半嵌套循环等。嵌套循环的缺点，在大量数据下会发生大量的随机读。
OJ08题：876. 链表的中间结点
吴先生的博客
11-12 361
过程简单，这题主要在于我们怎样让循环停下来，我们来分析一下：我们先来看一下有奇数个节点：我们可以看到，当slow指向中间节点的时候fast->next = NULL,这时候循环结束有偶数个节点：这个时候当slow指向中间节点的时候，fast指向NULL；对这两种情况分析我们知道，当fast指向NULL或fast->next=NULL时，循环结束，此时，slow指向的节点为中间节点，
iOS5 ARC完全解析
"ARC完全指南" 本文档是关于iOS5中的自动引用计数（Automatic Reference Counting，简称ARC）的全面指南。ARC是iOS开发中的一项重要技术，它通过编译器自动管理对象的内存，从而减轻了开发者的负担。本文将详细介绍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值