Round2

这里写目录标题

F.双端队列(数据结构)

  1. 一个两边都能操作的队列
  2. 可以通过 O ( 1 ) O(1) O(1)实现队列reverse操作,可以 O ( n ) O(n) O(n)解决本题。
  3. 要手打。
struct deque{
	int buffer[N<<1];
	int head=N,tail=N-1;
	bool rev;
	bool empty(){
		return tail<head; 
	} 
	int size(){
		return tail-head+1;
	}
	int front(){
		return rev? buffer[tail]:buffer[head];
	} 
	int back(){
		return rev? buffer[head]:buffer[tail];
	}
	void push_front(int x){
		rev? buffer[++tail]=x: buffer[--head]=x;
	}
	void push_back(int x){
		rev? buffer[--head]=x: buffer[++tail]=x;
	}
	void pop_back(){
		rev? head++:tail--;
	}
	void pop_front(){
		rev? tail--:head++;
	}
	void reverse(){
		rev^=1;
	}
}q;

F 反转区间

确定k+反转标记,逐个处理当前的数。前面的一定处理好了,所以只存当前的数连着的的后k个

#include<bits/stdc++.h>
using namespace std; 
const int N = 1e5 + 5;
int a[N];
struct deque{
	int buffer[N<<1];
	int head=N,tail=N-1;
	bool rev;
	bool empty(){
		return tail<head; 
	} 
	int size(){
		return tail-head+1;
	}
	int front(){
		return rev? buffer[tail]:buffer[head];
	} 
	int back(){
		return rev? buffer[head]:buffer[tail];
	}
	void push_front(int x){
		rev? buffer[++tail]=x: buffer[--head]=x;
	}
	void push_back(int x){
		rev? buffer[--head]=x: buffer[++tail]=x;
	}
	void pop_back(){
		rev? head++:tail--;
	}
	void pop_front(){
		rev? tail--:head++;
	}
	void reverse(){
		rev^=1;
	}
}q;
int main(){
	int n,k=0,l=0,r=0;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		if(a[i]!=i && !l){
			l=i;
		}
		if(l&&a[i]==l){
			r=i;
		}
	}
	k=r-l+1; 
	int flag =1;
	if(k==0){
		cout<<"yes\n1";
	}
	else{	
		for(int i=1;i<=k;i++){
			q.push_back(a[i]);
		}
		for(int i=1;i<=n;i++){
			//cout<<i<<" "<<q.front()<<" "<<k<<endl;
			if(q.front()!=i && q.size()==k) q.reverse();
			if(q.front()!=i){
				flag =0;
				break;
			}
			q.pop_front();
			if(i+k<=n){
				q.push_back(a[i+k]);
			}
		}
		if(flag){
			cout<<"yes\n"<<k;
		}else{
			cout<<"no";
		}		
		
	}
}
以下是PRESENT模块的完整代码,其中添加了随机掩码以提高安全性: ``` module PRESENT(res, state, key, mask); input [63:0] state; input [79:0] key; input [63:0] mask; output [63:0] res; wire [63:0] res1, res2, res3, res4, res5, res6, res7, res8, res9, res10, res11, res12, res13, res14, res15, res16; wire [79:0] key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16; // Round keys generation gen_keys(key, key1, key2, key3, key4, key5, key6, key7, key8, key9, key10, key11, key12, key13, key14, key15, key16); // Random mask wire [63:0] state_masked = state ^ mask; // Round 1 Round U1(res1, state_masked, key, key1, 5'b00001); // Remove mask wire [63:0] state_unmasked1 = res1 ^ mask; // Round 2 Round U2(res2, state_unmasked1, key1, key2, 5'b00010); // Remove mask wire [63:0] state_unmasked2 = res2 ^ mask; // Round 3 Round U3(res3, state_unmasked2, key2, key3, 5'b00011); // Remove mask wire [63:0] state_unmasked3 = res3 ^ mask; // Round 4 Round U4(res4, state_unmasked3, key3, key4, 5'b00100); // Remove mask wire [63:0] state_unmasked4 = res4 ^ mask; // Round 5 Round U5(res5, state_unmasked4, key4, key5, 5'b00101); // Remove mask wire [63:0] state_unmasked5 = res5 ^ mask; // Round 6 Round U6(res6, state_unmasked5, key5, key6, 5'b00110); // Remove mask wire [63:0] state_unmasked6 = res6 ^ mask; // Round 7 Round U7(res7, state_unmasked6, key6, key7, 5'b00111); // Remove mask wire [63:0] state_unmasked7 = res7 ^ mask; // Round 8 Round U8(res8, state_unmasked7, key7, key8, 5'b01000); // Remove mask wire [63:0] state_unmasked8 = res8 ^ mask; // Round 9 Round U9(res9, state_unmasked8, key8, key9, 5'b01001); // Remove mask wire [63:0] state_unmasked9 = res9 ^ mask; // Round 10 Round U10(res10, state_unmasked9, key9, key10, 5'b01010); // Remove mask wire [63:0] state_unmasked10 = res10 ^ mask; // Round 11 Round U11(res11, state_unmasked10, key10, key11, 5'b01011); // Remove mask wire [63:0] state_unmasked11 = res11 ^ mask; // Round 12 Round U12(res12, state_unmasked11, key11, key12, 5'b01100); // Remove mask wire [63:0] state_unmasked12 = res12 ^ mask; // Round 13 Round U13(res13, state_unmasked12, key12, key13, 5'b01101); // Remove mask wire [63:0] state_unmasked13 = res13 ^ mask; // Round 14 Round U14(res14, state_unmasked13, key13, key14, 5'b01110); // Remove mask wire [63:0] state_unmasked14 = res14 ^ mask; // Round 15 Round U15(res15, state_unmasked14, key14, key15, 5'b01111); // Remove mask wire [63:0] state_unmasked15 = res15 ^ mask; // Round 16 Round U16(res16, state_unmasked15, key15, key16, 5'b10000); // Remove mask res = res16 ^ mask; endmodule ``` 其中的 `mask` 参数为随机掩码,使用 `^` 运算符对输入数据进行掩蔽,然后进行PRESENT加密算法的一轮运算。在每一轮运算结束后,再次使用 `^` 运算符移除随机掩码。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值