首页 > 其他分享 >CSP-S 2023

CSP-S 2023

时间:2024-09-11 16:15:31浏览次数:12  
标签:__ name int 2023 他妈的 now CSP 模拟

T1

直接 \(10^{5}\) 枚举状态就过了,合法的非零差分数量只可能为 \(1,2\)(\(0\) 相当于没转,按照题意 “都不是正确密码” 是不符的)

需要注意的是形如 0 9 1 1 1 -> 1 0 1 1 1 这样的合法状态

#include<bits/stdc++.h>
using namespace std;
int n;
int a[10][9];
int p[6];
bool check(int id){
	int r[6];
	int cnt=0;
	for(int i=1;i<=5;++i){
		r[i]=a[id][i]-p[i];
        while(r[i]<0) r[i]+=10;
	}
	for(int i=1;i<=5;++i){
		if(r[i]!=0){
            cnt++;
        }
	}
    /*
    1 9
    9 7
    8 -2
    8 6
    7 -3
    */
	if(cnt==1){
		return true;
	}
	else if(cnt==2){
		for(int i=1;i<=4;++i){
			if(r[i]!=0 and r[i+1]==r[i]){
				return true;
			}
		}
		return false;
	}
	return false;
}
int main(){
    //freopen("lock.in","r",stdin);
    //freopen("lock.out","w",stdout);
	cin>>n;
	for(int i=1;i<=n;++i){
		for(int j=1;j<=5;++j){
			cin>>a[i][j];
		}
	}
	int ans=0;
	for(p[1]=0;p[1]<=9;++p[1]){
		for(p[2]=0;p[2]<=9;++p[2]){
			for(p[3]=0;p[3]<=9;++p[3]){
				for(p[4]=0;p[4]<=9;++p[4]){
					for(p[5]=0;p[5]<=9;++p[5]){
						bool can=true;
						for(int i=1;i<=n;++i){
							if(!check(i)){
								can=false;
								break;
							}
						}
						if(can) ans++;
					}
				}
			}
		}
	}
//	cout<<cnt1<<" "<<cnt2<<endl;
	cout<<ans<<endl;
} 

T2

首先能想到一个 \(O(n)\) 的 check(),就是开一个栈遍历,入栈时判断栈顶元素与放入元素能不能消,能消就消掉,最后判断栈是否非空

由此想到 \(n^{2}\) 做法,枚举开头,做 \(n\) 次 check,每当栈空就统计一次答案

由此想到 \(n\log n\) 做法,考虑只对整体 check() 一次,假如 \(i\neq j\),但 \(i,j\) 处栈的状态相同,那么就可以知道 \(i,j\) 之间的元素一定是可消除的,推广,假设有 \(k\) 个栈状态相同,对答案的贡献就是 \(\frac{k(k-1)}{2}\)

因此想到哈希,但是我一开始用的是异或哈希只有 20pts,想了一下发现异或哈希有交换律,会被 abab 这样的数据卡掉

直接普通哈希即可. 我看到题解区还有矩阵乘法的构造方法,总之选择的哈希算法无交换律就行

然后因为每次计算哈希值都从头计算,导致有一个 \(n^{2}\log n\) 的神奇复杂度过了 90pts,然后被随机数据卡了(因为随机数据的匹配值太小,导致栈里元素总是多的,会拉高复杂度)

实际上可以这么转移:

  • 栈空 \(h_{i}=s_{i}\)
  • 配对 \(h_{i}=h_{lst_{top}}\),\(lst_{top}\) 是栈顶元素的前一个元素
  • 未匹配,\(h_{i}=h_{top}*num+s_{i}\),注意这里应该是 \(h_{top}\) 而不是 \(h_{i-1}\),因为上一个元素可能被弹出去了
#include<bits/stdc++.h>
using namespace std;
#define endl '\n'
template<typename T>
void read(T& x){
	x=0;bool sym=0;char c=getchar();
    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
    while(isdigit(c)){x=x*10+c-48;c=getchar();}
    if(sym)x=-x;
}
template<typename T,typename... Args>
void read(T& x,Args&... args){
    read(x);read(args...);
}
int n;
string s;
inline unsigned long long _hash(stack<long long> st){
	unsigned long long res=0;
	while(!st.empty()){
		res=res*233ull+st.top();
		st.pop();
	}
	return res;
}
struct node{
	char num;
	int pla;
};
stack<node>st;
unordered_map<unsigned long long,long long>mp;
unsigned long long __hash[2000001];
int main(){
//	freopen("P9753_11.in","r",stdin);
	cin>>n>>s;
	s='?'+s;
	mp[0]++;
	__hash[0]=0;
	for(int i=1;i<=n;++i){
		if(st.empty()){
			st.push({s[i],i});
			__hash[i]=s[i];
			mp[__hash[i]]++;
		}
		else if(st.top().num==s[i]){
			__hash[i]=__hash[st.top().pla-1];
			st.pop();
			mp[__hash[i]]++;
		}
		else{
			__hash[i]=(__hash[st.top().pla]*233ull+s[i]);
			st.push({s[i],i});
			mp[__hash[i]]++;
		}
//		cout<<__hash[i]<<endl;
	}
	long long ans=0;
	for(auto i:mp){
//		cout<<i.second<<endl;
		ans+=((i.second)*(i.second-1))/2;
	}
	cout<<ans<<endl;
}

T3

他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟他妈的谁放的大模拟

  • 末端 \(addr=\) 首位 \(addr+size\large{-1}\),5pts
  • 考虑没声明就问你的情况,这样的情况会在操作 \(4\) 中出现,15pts
  • 注意结构体的对齐,不是根据 \(totsize\),而是 \(\max\{subsize\}\),25pts
  • 结构体内部元素是按照内部元素对齐方式对齐,而不是按照结构体对齐方式对齐,也就是 \(totsize\) 可能并不等于 \(k\times \max\{subsize\}\),65pts
  • 一些奇奇怪怪的变量问题,100pts

耗费了下午一+下午二+晚新闻+晚一+晚二+晚三/2=250min

因为这个模拟比较小所以没写注释,你们不要学这种坏习惯,否则有概率导致忘掉自己写的是什么导致需要重新打

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define type_byte 1
#define type_short 2
#define type_int 4
#define type_long 8
#define type_stru 9
ofstream cth;
struct stru{
	map<string,int>mem_id;
	map<int,string>mem_name;
	vector<int>mem_type;
	vector<int>mem_size;
	map<int,int>str_mem_id;
	vector<int>mem_addr;
	int cnt=-1;
	int maxsize,totsize,totaddr=0;
};
vector<stru>str;
vector<int>address;
map<string,int>str_id;
int now_address=0;
int cnt=-1,strcnt=-1;
vector<bool>isstr;
map<string,int>id;
map<int,string>name;
vector<int>str_reflect_id;
vector<int>sizeall;
int add_new(string _name,int size,bool _isstr,int reflect_id){
	if(_isstr) while(now_address%str[reflect_id].maxsize!=0) now_address++;
	else while(now_address%size!=0) now_address++;
	id[_name]=++cnt;
	name[cnt]=_name;
	address.push_back(now_address);
	int res=now_address;
	now_address+=size;
	isstr.push_back(_isstr);
	str_reflect_id.push_back(reflect_id);
	sizeall.push_back(size);
	return res;
}
namespace operation1{
	int mem_add_new(int strid,int size,int _isstr,int totsize){
//		if(str[strid].totaddr!=0) str[strid].totaddr++;
		while(str[strid].totaddr%size!=0) str[strid].totaddr++;
//		cth<<"[struct] new var from "<<str[strid].totaddr<<endl;//" to "<<str[strid].totaddr+totsize-1<<endl;
		int res=str[strid].totaddr;
		str[strid].totaddr+=totsize;
		return res;
	}
	void fixed_size(int strid,int masxsize){
		while(str[strid].totaddr%masxsize!=0) str[strid].totaddr++;
	}
	void act(){
		int k;string name;
		cin>>name>>k;
//		cth<<"new struct "<<name<<" ["<<k<<"]"<<endl;
		str.push_back({});strcnt++;
		str_id[name]=strcnt;
		for(int i=1;i<=k;++i){
			string type_name,_name;
			cin>>type_name>>_name;
			str[strcnt].mem_id[_name]=++str[strcnt].cnt;
			str[strcnt].mem_name[str[strcnt].cnt]=_name;
//			cth<<"["<<type_name<<"]";
			if(type_name=="byte"){
				str[strcnt].mem_type.push_back(type_byte);
				str[strcnt].mem_size.push_back(type_byte);
				str[strcnt].mem_addr.push_back(mem_add_new(strcnt,type_byte,false,type_byte));
			}
			else if(type_name=="short"){
				str[strcnt].mem_type.push_back(type_short);
				str[strcnt].mem_size.push_back(type_short);
				str[strcnt].mem_addr.push_back(mem_add_new(strcnt,type_short,false,type_short));
			}
			else if(type_name=="int"){
				str[strcnt].mem_type.push_back(type_int);
				str[strcnt].mem_size.push_back(type_int);
				str[strcnt].mem_addr.push_back(mem_add_new(strcnt,type_int,false,type_int));
			}
			else if(type_name=="long"){
				str[strcnt].mem_type.push_back(type_long);
				str[strcnt].mem_size.push_back(type_long);
				str[strcnt].mem_addr.push_back(mem_add_new(strcnt,type_long,false,type_long));
			}
			else{
				str[strcnt].mem_type.push_back(type_stru);
				str[strcnt].mem_size.push_back(str[str_id[type_name]].maxsize);
				str[strcnt].str_mem_id[i-1]=str_id[type_name];
				str[strcnt].mem_addr.push_back(mem_add_new(strcnt,str[str_id[type_name]].maxsize,true,str[str_id[type_name]].totsize));
			}
			str[strcnt].maxsize=max(str[strcnt].maxsize,str[strcnt].mem_size.back());
		}
		fixed_size(strcnt,str[strcnt].maxsize);
		str[strcnt].totsize=str[strcnt].totaddr;
		cout<<str[strcnt].totsize<<" "<<str[strcnt].maxsize<<endl;
//		cth<<"struct end: totsize["<<str[strcnt].totsize<<"]"<<endl;
	}
}
namespace operation2{
	void act(){
		string type_name,_name;
		cin>>type_name>>_name;
		if(type_name=="byte"){
			cout<<add_new(_name,type_byte,false,-1)<<endl;
		}
		else if(type_name=="short"){
			cout<<add_new(_name,type_short,false,-1)<<endl;
		}
		else if(type_name=="int"){
			cout<<add_new(_name,type_int,false,-1)<<endl;
		}
		else if(type_name=="long"){
			cout<<add_new(_name,type_long,false,-1)<<endl;
		}
		else{
//			cout<<"gogogogogo "<<_name<<" "<<str_id[type_name]<<endl;
			cout<<add_new(_name,str[str_id[type_name]].totsize,true,str_id[type_name])<<endl;
		}
//		cth<<"[struct] new var from "<<address[cnt]<<endl;
		//cth<<"new var "<<type_name<<" '"<<_name<<"' in address "<<address[cnt]<<" to "<<address[cnt]+sizeall[cnt]-1<<endl;
	}
}
namespace operation3{
	int judge_remain(int strid,string remain){
//		cout<<"judge remain "<<" "<<strid<<" "<<remain<<endl;
		if(remain.empty()) return 0;
		int i=0;string nam,rem;
		for(i=0;i<=(int)remain.length()-1;++i){
			if(remain[i]=='.'){
				break;
			}
			nam.push_back(remain[i]);
		}
		for(i++;i<=(int)remain.length()-1;++i){
			rem.push_back(remain[i]);
		}
//		cout<<"tyope ";
//		for(int i:str[strid].mem_type) cout<<i<<" ";
//		cout<<endl;
		if(str[strid].mem_type[str[strid].mem_id[nam]]!=type_stru){
//			cout<<"yes "<<nam<<endl;
			return str[strid].mem_addr[str[strid].mem_id[nam]];
		}
		else{
			return str[strid].mem_addr[str[strid].mem_id[nam]]+judge_remain(str[strid].str_mem_id[str[strid].mem_id[nam]],rem);
		}
	}
	void act(){
		string x;
		cin>>x;
		int i=0;string nam,rem;bool hasdot=false;
		for(i=0;i<=(int)x.length()-1;++i){
			if(x[i]=='.'){
				hasdot=true;
				break;
			}
			nam.push_back(x[i]);
		}
		for(i++;i<=(int)x.length()-1;++i){
			rem.push_back(x[i]);
		}
		int res=0;
//		cout<<"judge "<<nam<<" "<<rem<<endl;
		if(hasdot){
//			cth<<"JUDGE ADDRESS "<<x<<endl;
//			cout<<" ------"<<id[nam]<<" "<<str_reflect_id[id[nam]]<<endl;
			cout<<(res=address[id[nam]]+judge_remain(str_reflect_id[id[nam]],rem))<<endl;
//			cth<<"JUDGE END: "<<res<<endl;
		}
		else{
//			cth<<"JUDGE ADDRESS "<<x<<endl;
			cout<<(res=address[id[nam]])<<endl;
//			cth<<"JUDGE END: "<<res<<endl;
		}
	}
}
namespace operation4{
	string judge_remain(int strid,int remain){
//		cth<<"JUDGE REMAIN-----"<<strid<<" "<<remain<<endl;
//		if(str[strid].cnt==-1) return "";
		int _id=0;
		str[strid].mem_addr.push_back(1e18);
		for(_id=0;_id<=str[strid].cnt;++_id){
			if(remain>=str[strid].mem_addr[_id] and remain<str[strid].mem_addr[_id+1]) break;
		}
//		cth<<"[[[[[find "<<_id<<" "<<str[strid].mem_addr[_id]<<" "<<str[strid].mem_addr[_id]+str[strid].mem_size[_id]-1<<endl;
//		cth<<"judge remain ::::: "<<strid<<" "<<remain<<endl;
		if(str[strid].mem_type[_id]!=type_stru){
			if(str[strid].mem_addr[_id]<=remain and str[strid].mem_addr[_id]+str[strid].mem_size[_id]-1>=remain);
			else{
//				cth<<"Error in "<<strid<<" when remain "<<remain<<" : find "<<_id<<" ["<<str[strid].mem_addr[_id]<<","<<str[strid].mem_addr[_id]+str[strid].mem_size[_id]-1<<"]"<<endl;
				return "";
			}
//			if(remain%str[strid].maxsize!=0) return "";
			return str[strid].mem_name[_id];
		}
		else{
			string t=judge_remain(str[strid].str_mem_id[_id],remain-str[strid].mem_addr[_id]);
			if(t.empty()) return "";
			return (str[strid].mem_name[_id]+"."+t);
		}
		str[strid].mem_addr.pop_back();
	}
	void act(){
		int addr;
		cin>>addr;
//		cth<<"JUDGE-------- "<<addr<<endl;
		if(address.empty()){
			cout<<"ERR"<<endl;
			return;
		}
		address.push_back(1e18);
		int _id=0;
		for(_id=0;_id<=cnt;++_id){
			if(address[_id]<=addr and address[_id+1]>addr) break;
		}
//		cout<<"id-----"<<_id<<endl;
		if(isstr[_id]==false){
			if(addr<address[_id] or addr>address[_id]+sizeall[_id]-1){
				cout<<"ERR"<<endl;
			}
			else{
				cout<<name[_id]<<endl;
			}
		}
		else{
//			cth<<"into[ "<<address[_id]<<" "<<str[str_reflect_id[_id]].totsize<<endl;
			string t=judge_remain(str_reflect_id[_id],addr-address[_id]);
			if(t.empty()) cout<<"ERR"<<endl;
			else cout<<(name[_id]+"."+t)<<endl;
		}
		address.pop_back();
	}
}
/*
0 1
*/
int ops;
signed main(){
//	cth.open("CON");
//	#ifdef ONLINE_JUDGE
//	freopen("struct.in","r",stdin);
//	freopen("struct.out","w",stdout);
//	#else
//	freopen("y3.in","r",stdin);
//	freopen("out.out","w",stdout);
//	#endif
	cin>>ops;
	int op;
	while(ops--){
		cin>>op;
		if(op==1){
//			cout<<"st act 1"<<endl;
			operation1::act();
//			cout<<"ed act 1"<<endl;
		}
		if(op==2){
//			cout<<"st act 2"<<endl;
			operation2::act();
//			cout<<"ed act 2"<<endl;
		}
		if(op==3){
//			cout<<"st act 3"<<endl;
			operation3::act();
//			cout<<"ed act 3"<<endl;
		}
		if(op==4){
//			cout<<"st act 4"<<endl;
			operation4::act();
//			cout<<"ed act 4"<<endl;
		}
	}
}

T4

看到给了答案范围以及答案具有单调性,基本就是二分答案了

然而这道题二分答案不是太好写,有两个需要解决的. 显然我们应该有一个函数来求 “点 \(i\) 至少需要在第 \(d_{i}\) 天放下去,否则就到达不了预定高度” 中的 \(d_{i}\),考虑到 \(n\) 不是很卡,因此直接二分答案,写个二分套二分,但是显然里面还需要一个函数来求 “对给定的 \(a,b\) 和区间 \([l,r]\) 的树的高度”,这里需要我们推个简单式子

显然,当 \(c_{i}\gt 0\) 的时候,由于 \(b_{i}\ge 1\),所以直接求即可

否则,我们应该找出令 \(c_{i}x+b_{i}=0\) 的 \(x\),对左右两边求分段函数

这里需要注意的是,因为这里的 \(x\) 应该是整数,但是对该方程的计算结果不一定是整数,所以要处理一下取整问题

然后就可以 check 了,考虑怎么 check,一个容易想到的贪心思路是我们应该对节点的 \(d_{i}\) 从小到大排序,考虑到最小的 \(d_{i}\) 一定要优先求,因此每次都从当前 \(d_{i}\) 最小的 \(i\) 搜到根节点,沿途未种树的节点加起来和时间戳比对即可

被卡常的一个大幅度优化

设点 \(i\) 至少需要在第 \(d_{i}\) 天放下去,如果需要的优化幅度不是非常大(\(300ms\) 以内),那么直接判断是否存在 \(d_{i}=1 \operatorname{and} i\neq 1\) 即可

否则,维护每个节点的深度,那么当存在 \(d_{i}\lt deep_{i}\) 的时候就可以返回了

注意开 int128

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
template<typename T>
void read(T& x){
	x=0;bool sym=0;char c=getchar();
    while(!isdigit(c)){sym^=(c=='-');c=getchar();}
    while(isdigit(c)){x=x*10+c-48;c=getchar();}
    if(sym)x=-x;
}
template<typename T,typename... Args>
void read(T& x,Args&... args){
    read(x);read(args...);
}
int n;
struct area{
	int a,b,c;
	__int128 tot_days;
}a[100001];
inline __int128 calc(__int128 a,__int128 b,__int128 c,__int128 l,__int128 r){
	if(c>=0) return (r-l+1)*b+(r-l+1)*(l+r)/2*c;
	__int128 x=(1-b)/c;
	if(c<0) x=min(x,r);
	if(x<l) return r-l+1;
	if(x>r) return (r-l+1)*b+(r-l+1)*(l+r)/2*c;
	return (x-l+1)*b+(x-l+1)*(l+x)/2*c+r-x;
}
inline int cal_days(__int128 a,__int128 b,__int128 c,__int128 mid){
	//firstly cal the min x make the b+cx>=1
	//that if c>0 that cx>=1-b x>=(1-b)/c
	//     if c<0 that cx>=1-b x<=(1-b)/c
//	if(c==0){
		//always the same
//		return mid-ceil(a*1.0/max(1ll,b));
//	}
	if(calc(a,b,c,1,mid)<a) return false;
	int l=0,r=n,res=-2;
	while(l<=r){
		int _mid=(l+r)/2;
		if(calc(a,b,c,_mid,mid)>=a){
			l=_mid+1;
			res=_mid;
		}
		else{
			r=_mid-1;
		}
	}
	return res;
//	if(c>0){
//		
//	}
//	if(c<0){
//		
//	}
}
vector<int>e[100001];
int fa[100001];
void dfs(int now,int last){
	fa[now]=last;
	for(int i:e[now]){
		if(i!=last){
			dfs(i,now);
		}
	}
}
int p[100001];
bool vis[100001]={true};
int stk[100001];
inline bool judge(){
	memset(vis,0,sizeof vis);vis[0]=true;
	for(int i=1;i<=n;++i){
		p[i]=i;
	}
	sort(p+1,p+n+1,[](int x,int y){return a[x].tot_days<a[y].tot_days;});
	int times=0;
	for(int i=1;i<=n;i++){
		int now=p[i];
		stack<int>st;
		while(vis[now]==false and now!=0){
			st.push(now);
			vis[now]=true;
			now=fa[now];
		}
		if(!st.empty() and st.top()==0) st.pop();
		while(!st.empty()){
			if(a[st.top()].tot_days<++times){
//				cout<<"falsein "<<st.top()<<" "<<a[st.top()].tot_days<<" "<<times<<endl;
				return false;
			}
			st.pop();
		}
 	}
// 	cout<<"acc"<<endl;
 	return true;
}
inline bool check(int mid){
//	cout<<"checkin "<<mid<<endl;
	for(int i=1;i<=n;++i){
		a[i].tot_days=cal_days(a[i].a,a[i].b,a[i].c,mid);
//		a[i].tot_days=mid-a[i].tot_days;
//		cout<<a[i].tot_days<<" ";
		if(a[i].tot_days<0 or (a[i].tot_days==1 and i!=1)){
//			cout<<"falseout "<<endl;
			return false;
		}
	}
//	cout<<endl;
	return judge();
}
/*
4 2 4 2
*/
signed main(){
//	freopen("tree.in","r",stdin);
//	freopen("tree.out","w",stdout);
//	freopen("tree2.in","r",stdin);
//	freopen("out.out","w",stdout);
	read(n);
	for(int i=1;i<=n;++i){
		read(a[i].a,a[i].b,a[i].c);
	}
	for(int i=1;i<=n-1;++i){
		int x,y;
		read(x,y);
		e[x].push_back(y);
		e[y].push_back(x);
	}
	dfs(1,0);
	int l=0,r=1e9,ans=-1;
	while(l<=r){
//		cout<<"check "<<l<<" "<<r<<endl;
		int mid=(l+r)/2;
		if(check(mid)){
			r=mid-1;
			ans=mid;
		}
		else{
			l=mid+1;
		}
	}
	cout<<ans<<endl;
}

标签:__,name,int,2023,他妈的,now,CSP,模拟
From: https://www.cnblogs.com/HaneDaCafe/p/18407007

相关文章

  • CSP-S 2023 游记
    在CSP-S2024来临之际,补一下CSP-S2023游记CSP-S开题顺序:T1+T2+T4+T3时间分配:T130min,T21h,T42h,T330min场上即兴考试思路:快速切T1,死磕T2(没想到1h就想到了),接着T4试着AC(然后就深陷其中,红温了),T3场上忘了。T1正常发挥,T2其实也挺谁的,想到\(O(n^2)\)做法就一个......
  • 深入探索从ES6到ES2023
    从ES6到ES2023,我们深入探索ECMAScript(简称ES)的演变与发展,了解这一JavaScript标准背后的技术革新和进步。ECMAScript作为JavaScript的标准化版本,每年都在不断推出新版本,为开发者带来更加丰富和强大的功能。本文将从ES6的引入开始,逐步介绍到最新的ES2023,同时探讨这些新特性对......
  • MATLAB R2023b下载安装教程超详细的图文教程来了
    MATLABR2023b下载安装教程超详细的图文教程来了,MATLAB2023版在多个方面有显著提升。性能上,计算速度优化,大规模矩阵运算等执行更快,节省时间和资源;内存管理改进,减少内存泄漏和碎片化,提高程序稳定性。图形和可视化功能增强,高质量图形渲染使图像更清晰准确;新增交互式可视化工......
  • [COCI2022-2023#2] Tramvaji
    [COCI2022-2023#2]Tramvaji题意对于每个车站\(i\),给出一条信息。从车站\(j<i\)到车站\(i\)花费了时间\(t\)。求出哪两个站之间花费的时间最少。思路考虑求出\(s_i\)表示从\(1\)到\(i\)的最少时间。答案即\(\min_{i=2}^{n}s_i-s_{i-1}\)。对于给出的信息\(......
  • ZROI 2024 CSP 七连测
    Day1A.特工若两个特工\(i,j\)成功匹配,当且仅当\(x_i+y_j=x_j+y_i\),移项可得\(x_i-y_i=x_j-y_j\),所以只需要用一个map存一下每个值的数量,统计即可。B.提克塔可头考虑游戏的局面不会很多,最多只有\(3^9\)种情况,且这些情况组成了一个DAG。我们爆搜所有进程(共有\(9!\)......
  • CSP2024-18
    A题意:给出两个\(n\timesm\)的矩阵\(A,B\),一次操作可以使\(A\)或\(B\)的一行/列加一。求使\(A,B\)相等的最小操作次数。数据范围:\(n,m\le10^5,n\timesm\le10^5\)。令\(X=A-B\),则题目转化为每次可以使一行/列加减一,求使得\(X\)全零的最小操作数。设......
  • CSP模拟 矩阵操作
    涉及知识点:就是个推式子+贪心?前言感觉有点板,故记录一下以备后续所用。题意有两个$n\timesm$的矩阵\(A\)和\(B\),每次操作可以把\(A\)或者\(B\)的某一行/列全部\(+1\),最少几次操作\(A=B\)?思路首先想到的肯定是构造一个差分矩阵,即\(D=B-A\),问题转化为从一个零矩......
  • 9.10 模拟赛(炼石计划 11 月 15日 CSP-S 十连测 #10)
    炼石计划11月15日CSP-S十连测#10【补题】-比赛-梦熊联盟(mna.wang)复盘所有题先都浏览了一遍。其中T1见过。但当时是乱搞过的。但怎么乱搞的忘了。那就先做T1。有\(60\)分送的。尝试重新思考乱搞以获取剩余的\(40\)分。中间看了一眼T3。想了一分钟左右就会......
  • 一键下载,轻松应对工作挑战:Adobe InDesign 2023 最新版软件下载
    ##一键下载,轻松应对工作挑战:AdobeInDesign2023最新版软件下载在当今快节奏的工作环境中,效率和便捷性是成功的关键。无论是设计师、出版商还是营销人员,都需要一款功能强大且易于使用的排版软件来应对各种工作挑战。AdobeInDesign2023正是这样一款软件,它凭借其强大的功能和不......
  • 下载-轻松应对工作挑战:DW下载2023正版下载安装,2014-2023下载
    ##下载-轻松应对工作挑战:DW下载2023正版下载安装,2014-2023下载在当今数字化时代,高效的工作离不开强大的工具支持。AdobeDreamweaver(简称DW)作为一款专业的网页设计和开发工具,自2014年发布以来,凭借其强大的功能和便捷的操作,一直深受广大设计师和开发者的青睐。如今,DW已经更新至2023......