CF1208
打的话貌似能够涨分的样子?
A
水题
B
枚举左端点,看看右端点的最近位置
开一个类似于桶的东西维护一下上一次出现位置
左端点左边就删掉,否则就要将上一次出现的位置删掉
时间复杂度\(O(n^2)\)或者\(O(n^2logn)\)取决于是否离散化
貌似一个log就是二分答案
然后\(O(n)\)check一遍
#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cctype>
#include<vector>
#include<ctime>
#include<map>
#define LL long long
#define pii pair<int,int>
#define mk make_pair
#define fi first
#define se second
using namespace std;
const int N = 2003;
int a[N];
int pre[N];
map <int,int> m;
int n;
inline int read(){
int v = 0,c = 1;char ch = getchar();
while(!isdigit(ch)){
if(ch == '-') c = -1;
ch = getchar();
}
while(isdigit(ch)){
v = v * 10 + ch - 48;
ch = getchar();
}
return v * c;
}
int main(){
int ans = 0x3f3f3f3f;
n = read();
for(int i = 1;i <= n;++i){
a[i] = read();
if(!m[a[i]]) m[a[i]] = i;
else pre[i] = m[a[i]];
m[a[i]] = i;
// printf("%d\n",pre[i]);
}
bool flag = 1;
for(int i = 1;i <= n;++i){
m.clear();
int r = 0;
for(int j = 0;j < i;++j){
if(m[a[j]] == -1) {flag = 0;break;}
m[a[j]] = -1;
}
if(!flag) break;
for(int j = i;j <= n;++j){
if(m[a[j]] == -1) r = max(r,j);
else if(m[a[j]] != 0){
r = max(r,m[a[j]]);
m[a[j]] = j;
}
else m[a[j]] = j;
}
if(r != 0) ans = min(ans,r - i + 1);
else ans = 0;
}
cout << ans;
return 0;
}
听说貌似有\(O(n)\)做法不大会
C
构造题
分成四块考虑,因为题目中保证是\(4\)的倍数
首先,如果没有\(0-n^2-1\)这个限制
这样子肯定符合要求
\(\begin{array}{cccc}{0} & {0} & {1} & {1} \\ {0} & {0} & {1} & {1} \\ {2} & {2} & {3} & {3} \\ {2} & {2} & {3} & {3}\end{array}\)
但是这样肯定不符合题意
那么我们就对于给每一部分编号
把这一部分整体+4
\(\begin{array}{cccc}{0} & {4} & {1} & {5} \\ {8} & {12} & {9} & {13} \\ {2} & {6} & {3} & {7} \\ {10} & {14} & {11} & {15}\end{array}\)
如果没有保证\(n\)是\(4\)的倍数,那么这样构造一定不对,因为每一行都有数出现了奇数次
由于每一行每一列
每个\(4\)的倍数都只被加了两次
异或起来都答案是没有影响的
那么我们照着这样子构造就好了
D
感觉D是个一眼题,CD应该换一下位置的
最右边的\(0\)对应的位置一定是\(1\)
然后把\(1\)的贡献去掉之后,最右边的\(0\)一定是\(2\)
以此类推
线段树搞一搞就好了
#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cctype>
#include<vector>
#include<ctime>
#define LL long long
#define pii pair<int,int>
#define mk make_pair
#define fi first
#define se second
using namespace std;
const int N = 2e5 + 3;
const LL INF = 1e15;
LL dis[N];
int an[N];
int n,root;
inline LL read(){
LL v = 0,c = 1;char ch = getchar();
while(!isdigit(ch)){
if(ch == '-') c = -1;
ch = getchar();
}
while(isdigit(ch)){
v = v * 10 + ch - 48;
ch = getchar();
}
return v * c;
}
struct Tree{
int t;
struct node{
LL maxx;
LL tag;int pos;
int lc,rc;
}a[N << 2];
inline void pushup(int u){
if(a[a[u].lc].maxx < a[a[u].rc].maxx) a[u].maxx = a[a[u].lc].maxx,a[u].pos = a[a[u].lc].pos;
else a[u].maxx = a[a[u].rc].maxx,a[u].pos = a[a[u].rc].pos;
}
inline void pushdown(int u,int l,int r){
if(!a[u].tag) return;
a[a[u].lc].maxx += a[u].tag;
a[a[u].rc].maxx += a[u].tag;
a[a[u].lc].tag += a[u].tag;
a[a[u].rc].tag += a[u].tag;
a[u].tag = 0;
return ;
}
inline void build(int &u,int l,int r){
if(!u) u = ++t;
if(l == r){
a[u].maxx = dis[l];
a[u].pos = l;
return ;
}
int mid = (l + r) >> 1;
build(a[u].lc,l,mid);build(a[u].rc,mid + 1,r);
pushup(u);
}
inline void updata(int u,int l,int r,int ll,int rr,LL w){
if(ll > rr) return;
if(l == ll && r == rr){
a[u].maxx += w;
a[u].tag += w;
return ;
}
pushdown(u,l,r);
int mid = (l + r) >> 1;
if(rr <= mid) updata(a[u].lc,l,mid,ll,rr,w);
else if(ll > mid) updata(a[u].rc,mid + 1,r,ll,rr,w);
else{
updata(a[u].lc,l,mid,ll,mid,w);
updata(a[u].rc,mid + 1,r,mid + 1,rr,w);
}
pushup(u);
}
inline int query(){return a[root].pos;}
}T;
int main(){
n = read();
for(int i = 1;i <= n;++i) dis[i] = read();
T.build(root,1,n);
// cout << "GG" << endl;
for(int i = 1;i <= n;++i){
int x = T.query();
an[x] = i;
T.updata(root,1,n,x + 1,n,-i);
T.updata(root,1,n,x,x,INF);
}
for(int i = 1;i <= n;++i) printf("%d ",an[i]);
return 0;
}
E
当时就硬是没想出来差分的技巧
首先每个位置可以取到的数肯定是
\([x - (w - len),x+(w -len)]\)这个区间的最大值
之后我们分两种情况讨论
首先
当\(len >= w -len\)时
这时候会长成这个样子
我们设\(d = w - len\)表示能够滑动的距离
对于一个位置\(x\)
首先,绿色部分是只能够从左向右取最大值\([x - d,x]\)
红色只能从右向左取最大值\([x,x + d]\)
中间部分呢？这一部分你会发现
这一部分其实可以和红色或者绿色任意一部分合起来算
这个时候注意不要把黄色部分重复计算就好
当\(len < w - len\)时
这个时候,中间的黄色部分的答案,就变成了序列中的最大值和\(0\)取max
因为中间部分是可以取到序列中的任意数
所以我们只需要维护区间最大值,这个东西随便搞搞吧
注意判断越界时要和\(0\)取max,表示可以不选
#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cctype>
#include<vector>
#include<deque>
#include<ctime>
#define LL long long
#define pii pair<int,int>
#define mk make_pair
#define fi first
#define se second
using namespace std;
const int N = 1e6 + 3;
const int INF = 2e9;
int n,len,w;
int f[21][N];
LL ans[N];
int lg[N];
inline int read(){
int v = 0,c = 1;char ch = getchar();
while(!isdigit(ch)){
if(ch == '-') c = -1;
ch = getchar();
}
while(isdigit(ch)){
v = v * 10 + ch - 48;
ch = getchar();
}
return v * c;
}
inline void pre(){
for(int j = 1;(1 << j) <= len;++j){
for(int i = 1;i + (1 << j) - 1 <= len;++i)
f[j][i] = max(f[j - 1][i],f[j - 1][i + (1 << (j - 1))]);
}
}
inline int work(int l,int r){
int k = lg[r - l + 1];
return max(f[k][l],f[k][r - (1 << k) + 1]);
}
inline int query(int l,int r){
if(l < 1 || r > len) return max(0,work(max(1,l),min(len,r)));
else return work(l,r);
}
int main(){
lg[1] = 0;
for(int i = 2;i <= 1000000;++i) lg[i] = lg[i >> 1] + 1;
n = read(),w = read();
for(int i = 1;i <= n;++i){
len = read();
for(int j = 1;j <= len;++j) f[0][j] = read();
pre();
for(int i = 1;i <= len;++i){
int k = query(i,i + w - len);
ans[i + w - len] += k;
ans[i + w - len + 1] -= k;
}
for(int i = 1;i <= min(len,w - len);++i){
int k = query(i - w + len,i);
ans[i] += k;
ans[i + 1] -= k;
}
if(len < w - len){
int k = max(0,query(1,len));
ans[len + 1] += k;
ans[w - len + 1] -= k;
}
}
for(int i = 1;i <= w;++i) {ans[i] += ans[i - 1];printf("%lld ",ans[i]);}
return 0;
}
F
神仙题解\(SOS DP\)
题目大意求\((i,j,j)i < j < k\)使得\(a_i | (a_j \&a_i)\)最大
\(n <= 10^6,a_i < 2^{21}\)
考虑从从后向前枚举\(i\)
从高位向低位贪心
设\(dp_x\)表示\(x\)设个二进制集合被多少数完全包含
每次对于一个\(a_i\)
从大到小枚举所有位
如果这个位\(j\)不是\(1\)同时满足当前贪心的结果\(x\),\(x | (1 << j)\)被超过两个数包含(保证\(\&\)完之后有这个数)就将这一位加入贪心的答案
更新完答案之后就把每一位包含\(a_i\)的加入
时间复杂度貌似有点爆炸
但是我们发现如果\(dp_x >=2\)那么直接return
所以每个位置最多被更新两次
均摊是\(2^{21}\)的复杂度
#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cctype>
#include<vector>
#include<ctime>
#define LL long long
#define pii pair<int,int>
#define mk make_pair
#define fi first
#define se second
using namespace std;
const int N = 1e6 + 3;
int a[N];
int cnt[N << 2];
int n;
inline int read(){
int v = 0,c = 1;char ch = getchar();
while(!isdigit(ch)){
if(ch == '-') c = -1;
ch = getchar();
}
while(isdigit(ch)){
v = v * 10 + ch - 48;
ch = getchar();
}
return v * c;
}
int ans = 0;
inline void ins(int x,int d){
if(cnt[x] >= 2) return;
if(d == -1){cnt[x]++;return;}
ins(x,d - 1);
if(x & (1 << d)) ins(x ^ (1 << d),d - 1);
}
inline int query(int x){
int now = 0;
for(int i = 20;i >= 0;--i) if(((x & (1 << i)) == 0) && cnt[now | (1 << i)] >= 2) now |= 1 << i;
return now | x;
}
int main(){
n = read();
for(int i = 1;i <= n;++i) a[i] = read();
for(int i = n;i >= 1;--i){
if(i <= n - 2) ans = max(ans,query(a[i]));
ins(a[i],20);
}
printf("%d\n",ans);
return 0;
}
京公网安备 11010502036488号