我又打了一个猝死场....
不过猝死倒是没有,就是自闭了.....
自闭过程如下:
当L_Y_T刚刚做完A,B打了一半时........
**kr : 您C题会做嘛? **
L_Y_T : 还没看啊
kr : wucstdio 切到D题了.....
A
仔细考虑一下就会发现,这个玩意是三个一循环的,然后就是sb题了
#include <bits/stdc++.h>
#define int long long
using namespace std ;
int T ;
signed main () {
cin >> T ;
while(T--) {
int n , a , b ;
cin >> a >> b >> n ;
int c = n%3 ;
// cout << c <<endl ;
if(c == 2) {
cout << (a^b) << endl ;
}else if(c == 0) {
cout << a <<endl ;
}else {
cout << b << endl ;
}
}
return 0 ;
}
B
离散化一下,用桶一存,然后二分
题解思路:删除子段后，前缀和后缀保持不变，可能长度为0.让我们修复不包含任何重复元素的前缀，并找到我们可以获得的最大后缀而不重复元素。我们可以使用map / set来跟踪元素。
#include<bits/stdc++.h>
#define int long long
#define maxn 2010
using namespace std ;
int n , num[maxn] ;
struct Node{
int lop , data ;
}LS[maxn] ;
bool cmp(Node x,Node y){
return x.data < y.data;
}
int Tong[maxn][maxn] ;
bool check(int Lenth) {
int flag = 1 ;
for (int l = 1 ; l + Lenth - 1 <= n ; l ++) {
int r = l + Lenth - 1 ;
bool F = 1 ;
for(int j = 1 ; j <= n ; j ++) {
if(Tong[n][j] - Tong[r][j] + Tong[l-1][j] > 1) { F = 0 ; break; }
}
if(F) return true ;
}
return false ;
}
signed main() {
cin >> n ;
for(int i = 1 ; i <= n ; i ++) { cin >> LS[i].data; LS[i].lop=i; }
sort(LS+1,LS+1+n,cmp);
int idx = 0 ;
LS[0].data = -1 ;
for(int i = 1 ; i <= n ; i ++){
if(LS[i].data != LS[i-1].data)
num[LS[i].lop] = ++idx ;
else
num[LS[i].lop] = idx ;
}
for(int i = 1 ; i <= n ; i ++) {
for(int j = 1 ; j <= n ; j ++)
Tong[i][j] = Tong[i-1][j];
Tong[i][num[i]]++ ;
}
int l = 0 , r = n ;
while(l <= r) {
int mid = (l+r) / 2 ;
if(check(mid))
r = mid - 1 ;
else
l = mid + 1 ;
}
cout<< l <<endl ;
return 0;
}
C
这道题,我就一句话....
张老板 NB
思路
把这个n*n的玩意分成四个象限,然后先填充第一象限的,再分别复制到二三四象限,然后为了避免重复分别加123,搞成这个亚子
| 1 | 1 | 2 | 2 |
|---|---|---|---|
| 1 | 1 | 2 | 2 |
| 3 | 3 | 0 | 0 |
| 3 | 3 | 0 | 0 |
很显然的,这亚子是^起来都等于0的
然后在每个象限的对应位置插入相同的数.那么不就^后等于0辣?
代码
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define maxn 1010
using namespace std ;
int a[maxn][maxn] , n ;
int main() {
cin >> n ;
int tot = 0 ;
for(int i = 1 ; i <= n/2 ; i ++) {
for(int j = 1 ; j <= n/2 ; j ++,tot ++) {
a[i][j] = tot*4 + 1 ;
a[i][j+n/2] = tot*4 + 2 ;
a[i+n/2][j] = tot*4+3 ;
a[i+n/2][j+n/2] = tot*4 ;
}
}
for(int i = 1 ; i <= n ; i ++) {
for(int j = 1 ; j <= n ; j ++) {
cout << a[i][j] << " " ;
}
puts("") ;
}
return 0 ;
}
溜了溜了
D
我真的没有想到自己可以把这个题解写到D题
思路
让我们按照递增顺序从1到N填充数组。1将位于最后一个索引i，使得si = 0。从数组中查找并删除此索引i，对于大于i的所有索引，将其si值减小1.对数字2,3，... N重复此过程。在第i个回合中，用i减少元素。要查找值为零的最后一个索引，我们可以使用段树来获取具有延迟传播的范围最小查询。
这是题解的思路.然后我们按照题解的思路想想看啊.....由于输入的p[i]数组就相当于是个前缀和,那么我们可以从1到n枚举每个数,找到第一个不成立(也就是等于0的),然后将其他的全部-i,然后依次类推...
代码
#include <bits/stdc++.h>
#define int long long
#define maxn 250000
#define lson u<<1
#define rson u<<1|1
#define mid (l+r)/2
using namespace std ;
struct dy{
int minn , add ;
}tree[maxn*4] ;
int n , m , p[maxn] ;
int a[maxn];
void pushup(int u) {
tree[u].minn = min(tree[lson].minn,tree[rson].minn) ;
}
void pushdown(int u) {
if(tree[u].add) {
tree[lson].add += tree[u].add ;
tree[rson].add += tree[u].add ;
tree[lson].minn += tree[u].add ;
tree[rson].minn += tree[u].add ;
tree[u].add = 0 ;
}
return ;
}
void build(int u ,int l ,int r) {
if(l == r) {
tree[u].minn = a[l] ;
return ;
}
build(lson,l,mid) ;
build(rson,mid+1,r) ;
pushup(u) ;
}
void updata(int u,int l,int r,int ll ,int rr ,int v) {
if(ll > rr) return ;
if(l >= ll && r <= rr) {
tree[u].add += v ;
tree[u].minn += v ;
return ;
}
pushdown(u) ;
if(ll <= mid) updata(lson,l,mid,ll,rr,v) ;
if(rr > mid) updata(rson,mid+1,r,ll,rr,v) ;
pushup(u) ;
}
int query(int u,int l,int r) {
if(l == r) {
tree[u].minn = 1e18 ;
return l ;
}
pushdown(u) ;
int ans = 0 ;
if(!tree[rson].minn) ans = query(rson,mid+1,r) ;
else ans = query(lson,l,mid) ;
pushup(u) ;
return ans ;
}
signed main () {
cin >> n ;
for(int i = 1 ; i <= n ; i ++) {
cin >> a[i] ;
}
build(1,1,n) ;
for(int i = 1 ; i <= n ; i ++) {
int x = query(1,1,n) ;
p[x] = i ;
updata(1,1,n,x+1,n,-i) ;
}
for(int i = 1 ; i <= n ; i ++) {
cout << p[i] << " " ;
}
return 0 ;
}