暑假集训CSP提高模拟5

听好了：

7 月 22 日，比样的学长就此陷落。每个陷落的学长都将迎来一场模拟赛，为这些模拟赛带来全新的题面。

你所熟知的一切都将改变，你所熟悉的算法都将加诸比样的考验。

至此，一锤定音。

尘埃，已然落定。

#听好了 #听好了 #听好了

啥？你不知道这是什么梗？

其实是 Arcaea公式 说话喜欢套模板被大家效仿导致的.

A.简单的序列

显然这个题，假设序列中全为正数的话，那么我们应该从最右（大）端开始检查并更新.

首先从最右端开始一定不会与之前满足的合法状态冲突，因为运算过程中会越来越小，一定小于右端数字. 其次这样做一定是最优的，右端的每一个数都不会进行多余的操作.

假如这个题考虑负数的话也很简单，因为负数越除越大，因此只需要从左边开始就行了，需要注意的是因为 \(\lfloor{-1\over 2}\rfloor=-1\)，因此需要判一下死循环

比样的谁知道没有负数

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define main signed main()
#ifndef int
#define read(x) scanf("%d",&(x));
#define write(x) printf("%d",(x));
#else
#define read(x) scanf("%lld",&(x));
#define write(x) printf("%lld",(x));
#endif
#define endl putchar('\n')
#define sp putchar(' ')
#define we(x) write(x);endl
#define ws(x) write(x);sp
#define tests int cases;read(cases);while(cases--)
int a[301];
void print(int n){
	putchar(':');sp;
	for(int i=1;i<=n;++i){
		ws(a[i]);
	}
	endl;
}
main{
	tests{
		int n;read(n);int ans=0;
		for(int i=1;i<=n;++i){
			read(a[i]);
		}
		for(int i=1;i<=n-1;++i){
			if(a[i+1]>=0) break;
			while(a[i+1]<=a[i] and a[i+1]<0){
				ans++;
				a[i+1]=floor(a[i+1]/2.0);
//				print(n);
			}
		}
		for(int i=n;i>=2;--i){
			if(a[i-1]<=0) break;
			while(a[i-1]>=a[i] and a[i-1]>0){
				ans++;
				a[i-1]=floor(a[i-1]/2.0);
//				print(n);
			}
		}
		bool yes=true;
		for(int i=1;i<=n-1;++i){
			if(a[i]>=a[i+1]){
				yes=false;
				break;
			}
		}
		if(yes){
			we(ans);
		}
		else{
			we(-1ll);
		}
	}
}
/*
1
6
-2 -4 0 8 7 9
*/

B.简单的字符串

这个题放 T2 感觉有点水了，注意到 \(n\le 10000\)，所以直接用 \(26n\) 的算法就能过.

至于啥是 \(26n\) 的，枚举每个字母进行转移，因为其他字母转移了也没用，因此就不管，只对当前字母能转移就转移，最后统计次数，取最小值就行了

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define main signed main()
#ifndef int
#define read(x) scanf("%d",&(x));
#define write(x) printf("%d",(x));
#else
#define read(x) scanf("%lld",&(x));
#define write(x) printf("%lld",(x));
#endif
#define endl putchar('\n')
#define sp putchar(' ')
#define we(x) write(x);endl
#define ws(x) write(x);sp
#define tests int cases;scanf("%d",&cases);while(cases--)
string x;
struct ch{
	int id,tot;
	bool operator <(const ch &A)const{
		return tot>A.tot;
	}
};
ch cnt[256];
int reduce(int id,string x){
	bool yes=true;
	for(int i=1;i<=(int)x.length()-1;++i){
		if(x[i]!=x[i-1]){
			yes=false;
		}
	}
	if(yes){
		return 0;
	}
	int res=1;
//	cout<<"reduce "<<(char)id<<'\n';
	x.push_back('0');
	while(1){
//		cout<<x<<'\n';
		bool can=true;
		res++;
		for(int i=0;i<=(int)x.length()-1-res;++i){
			if(x[i+1]==id) x[i]=x[i+1];
			if(x[i]!=id) can=false;
//			cout<<x[i];
		}
//		cout<<"\n\n";
		if(can){
//			if(x[x.length()-1-res]!=id){
//				cout<<"tans "<<res+1<<'\n';return res+1;
//			}
//			else{
//				cout<<"aans "<<res-1<<'\n';
				return res-1;
//			}
		}
	}
}
main{
//	freopen("1.in","r",stdin);
	cin>>x;
	if(x.length()==1){
		cout<<0;endl;
		return 0;
	}
	for(int i=1;i<=255;++i){
		cnt[i].id=i;
	}
	for(int i=0;i<=(int)x.length()-1;++i){
		cnt[(int)x[i]].tot++;
	}
	int ans=0x3f3f3f3f;
	for(int i=1;i<=255;++i){
		if(cnt[i].tot){
			ans=min(ans,reduce(cnt[i].id,x));
		}
	}
	we(ans);
}

C.简单的博弈

博弈论，前面的世界以后再来探索吧

D.困难的图论

部分分考虑暴力建边跑 DIJ，复杂度 \(nm\log n\)

怎么会有人觉得 \(n^{3}\) 和 \(nm\log n\) 还需要斟酌一下的. 虽然这个题真实的 \(m\) 可能比较大，但是 DIJ 显然上限比较高，而且在 \(k\) 很大的时候跑得十分优秀.

要是我的话就再给一个 \(k=1\) 的部分分，或者构造卡一下暴力建边，因为 \(nm\log n\) 的 DIJ 在 \(n=1000\) 的范围下跑了一万两千毫秒.

显然做这个题的瓶颈在于边太多了，那我们可以考虑把每个 \(k\) 抽象出来建虚点

但是这样建边会有点问题，因为虚点毕竟不是缩点，建边后效率还是拉不上去.

考虑到两个点之间最短路有两种情况，一种是过虚点，一种不过. 如果过，这个点答案就是虚点的答案. 如果不过，就要减 \(1\)，相当于把第一步走虚点再走回来去掉.

再考虑到每个虚点内部（\(k\) 相等的分量内部）的图比较好求，因此考虑先分段处理出来再进行连接.

因为要手写 bitset，所以就只写了 bitset

#include<bits/stdc++.h>
using namespace std;
namespace hdk{
	unsigned long long maxull=(1ull<<63)-1+(1ull<<63);
	template<int siz>
	class bitset{
		private:
			unsigned long long s[int(ceil(siz/64.0))]={};
		public:
			inline int size(){
				return siz;
			}
			inline int array_size(){
				return int(ceil(siz/64.0));
			}
			inline void clear(){
				for(int i=0;i<=array_size()-1;++i){
					s[i]=0;
				}
			}
			bool operator [](int x){
				int pos=x/64;
				return ((s[pos]>>(x%64))&1);
			}
			inline unsigned long long &at(int pos){
				return s[pos];
			}
			inline void upset_down(int pos){
				int x=pos/64;
				s[x]^=(1ull<<(pos%64));
			}
			inline void upset_down(int l,int r){
				int pos1=l/64,pos2=r/64;
				if(pos1==pos2){
					for(int i=l;i<=r;++i){
						upset_down(i);
					}
					return;
				}
				for(int i=pos1+1;i<=pos2-1;++i){
					if(s[i]==0){
						s[i]=maxull;
					}
					else if(s[i]==maxull){
						s[i]=0;
					}
					else{
						for(int j=i*64;j<=(i+1)*64-1;++j){
							upset_down(j);
						}
					}
				}
				for(int i=l;i<=(pos1+1)*64-1;++i){
					upset_down(i);
				}
				for(int i=pos2*64;i<=r;++i){
					upset_down(i);
				}
			}
			inline void set(unsigned long long x){
				*this=x;
			}
			inline void set(int pos,bool value){
				if((*this)[pos]!=value){
					this->upset_down(pos);
				}
			}
			inline void set(int l,int r,bool value){
				int pos1=l/64,pos2=r/64;
				if(pos1==pos2){
					for(int i=l;i<=r;++i){
						set(i,value);
					}
					return;
				}
				if(value){
					for(int i=pos1+1;i<=pos2-1;++i){
						s[i]=maxull;
					}
				}
				else{
					for(int i=pos1+1;i<=pos2-1;++i){
						s[i]&=0;
					}
				}
				for(int i=l;i<=(pos1+1)*64-1;++i){
					set(i,value);
				}
				for(int i=pos2*64;i<=r;++i){
					set(i,value);
				}
			}
			hdk::bitset<siz> operator ~(){
				hdk::bitset<siz>ans;
				ans=*this;
				ans.upset_down(0,siz-1);
				return ans;
			}
			void operator =(unsigned long long x){
				s[0]=x;
			}
			void operator =(string x){
				for(int i=(int)x.length()-1;i>=0;--i){
					this->set(x.length()-1-i,x[i]-'0');
				}
			}
			hdk::bitset<siz> operator +(hdk::bitset<siz>A){
				hdk::bitset<siz>ans;
				int x=0;
				for(int i=0;i<=siz-1;++i){
					x+=(*this)[i]+A[i];
					ans.set(i,x&1);
					x>>=1;
				}
				return ans;
			}
			void operator +=(hdk::bitset<siz>A){
				*this=*this+A;
			}
			void print(bool iscomplete_print){
				bool iszero=iscomplete_print;
				for(int i=siz;i>=0;--i){
					bool res=(*this)[i];
					if(res==1){
						iszero=true;
					}
					if(iszero){
						putchar(res+'0');
					}
				}
				if(!iszero) putchar('0');
				putchar('\n');
			}
			void print(char devide=0,char end='\n',bool iscomplete_print=false){
				bool iszero=iscomplete_print;
				for(int i=siz;i>=0;--i){
					bool res=(*this)[i];
					if(res==1){
						iszero=true;
					}
					if(iszero){
						putchar(res+'0');
						if(devide!=0) putchar(devide);
					}
				}
				if(!iszero) putchar('0');
				if(end!=0) putchar(end);
			}
			hdk::bitset<siz> operator &(hdk::bitset<siz>A){
				hdk::bitset<siz> ans;
				for(int i=0;i<=siz-1;++i){
					ans.set(i,(*this)[i]&A[i]);
				}
				return ans;
			}
			hdk::bitset<siz> operator &(unsigned long long x){
				hdk::bitset<siz> A,ans;A.set(x);
				for(int i=0;i<=siz-1;++i){
					ans.set(i,(*this)[i]&A[i]);
				}
				return ans;
			}
			void operator &=(hdk::bitset<siz>A){
				*this=*this&A;
			}
			void operator &=(unsigned long long x){
				*this=*this&x;
			}
			hdk::bitset<siz> operator |(hdk::bitset<siz>A){
				hdk::bitset<siz> ans;
				for(int i=0;i<=siz-1;++i){
					ans.set(i,(*this)[i]|A[i]);
				}
				return ans;
			}
			hdk::bitset<siz> operator |(unsigned long long x){
				hdk::bitset<siz> A,ans;A.set(x);
				for(int i=0;i<=siz-1;++i){
					ans.set(i,(*this)[i]|A[i]);
				}
				return ans;
			}
			void operator |=(hdk::bitset<siz>A){
				*this=*this|A;
			}
			void operator |=(unsigned long long x){
				*this=*this|x;
			}
			hdk::bitset<siz> operator ^(hdk::bitset<siz>A){
				hdk::bitset<siz> ans;
				for(int i=0;i<=siz-1;++i){
					ans.set(i,(*this)[i]^A[i]);
				}
				return ans;
			}
			hdk::bitset<siz> operator ^(unsigned long long x){
				hdk::bitset<siz> A,ans;A.set(x);
				for(int i=0;i<=siz-1;++i){
					ans.set(i,(*this)[i]^A[i]);
				}
				return ans;
			}
			void operator ^=(hdk::bitset<siz>A){
				*this=*this^A;
			}
			void operator ^=(unsigned long long x){
				*this=*this^x;
			}
			inline bool empty(){
				bool x=0;
				for(int i=0;i<=array_size()-1;++i){
					x+=s[i];
				}
				return !x;
			}
			bool operator !(){
				return !empty();
			}
			inline unsigned long long it(){
				return s[0];
			}
			inline void set(){
				for(int i=0;i<=array_size()-1;++i){
					s[i]=maxull;
				}
			}
			inline void reset(){
				clear();
			}
			inline int count(){
				int ans=0;
				for(int i=0;i<=siz-1;++i){
					if((*this)[i]==1) ans++;
				}
				return ans;
			}
			bool operator <(hdk::bitset<siz> A){
				for(int i=array_size()-1;i>=0;--i){
					if(s[i]!=A.s[i]){
						return s[i]<A.s[i];
					}
				}
				return false;
			}
			bool operator <(unsigned long long x){
				hdk::bitset<siz>A;A=x;
				for(int i=array_size()-1;i>=0;--i){
					if(s[i]!=A.s[i]){
						return s[i]<A.s[i];
					}
				}
				return false;
			}
			bool operator ==(hdk::bitset<siz> A){
				for(int i=array_size()-1;i>=0;--i){
					if(s[i]!=A.s[i]){
						return false;
					}
				}
				return true;
			}
			bool operator ==(unsigned long long x){
				hdk::bitset<siz>A;A=x;
				for(int i=array_size()-1;i>=0;--i){
					if(s[i]!=A.s[i]){
						return false;
					}
				}
				return true;
			}
			inline bool test(int pos){
				return (*this)[pos];
			}
			inline string to_string(bool complete_print=false){
				string ans;
				if(complete_print){
					for(int i=siz-1;i>=0;--i){
						ans.push_back((*this)[i]+'0');
					}
					return ans;
				}
				else{
					bool iszero=false;
					for(int i=siz-1;i>=0;--i){
						bool res=(*this)[i];
						if(res==1) iszero=true;
						if(iszero) ans.push_back(res+'0');
					}
					if(!iszero) ans.push_back('0');
					return ans;
				}
			}
			bool operator !=(hdk::bitset<siz> A){
				return !(*this==A);
			}
			bool operator !=(unsigned long long x){
				return !(*this==x);
			}
			bool operator >(hdk::bitset<siz> A){
				return !(*this<A or *this==A);
			}
			bool operator >(unsigned long long x){
				return !(*this<x or *this==x);
			}
			bool operator >=(hdk::bitset<siz> A){
				return (*this>A or *this==A);
			}
			bool operator >=(unsigned long long x){
				return (*this>x or *this==x);
			}
			bool operator <=(hdk::bitset<siz> A){
				return (*this<A or *this==A);
			}
			bool operator <=(unsigned long long x){
				return (*this<x or *this==x);
			}
			inline bool all(){
				for(int i=0;i<=siz-1;++i){
					if((*this)[i]==0) return false;
				}
				return true;
			}
			inline bool any(){
				for(int i=0;i<=siz-1;++i){
					if((*this)[i]==1) return true;
				}
				return false;
			}
			inline bool none(){
				return !any();
			}
			inline void flip(){
				*this=~*this;
			}
			friend ostream& operator<<(ostream& output,hdk::bitset<siz> inx){
				inx.print(0,0);
				return output;
			}
			friend istream& operator>>(istream& input,hdk::bitset<siz> inx){
				unsigned long long x;
			   	input>>x;inx=x;
			   	return input;
			}
			friend hdk::bitset<siz> max(hdk::bitset<siz>A,hdk::bitset<siz>B){
				if(A>B) return A;
				else return B;
			}
			friend hdk::bitset<siz> min(hdk::bitset<siz>A,hdk::bitset<siz>B){
				if(A<B) return A;
				else return B;
			}
			hdk::bitset<siz> operator <<(int x){
				hdk::bitset<siz> ans;
				for(int i=siz-1;i>=x;--i){
					ans.set(i,(*this)[i-x]);
				}
				return ans;
			}
			hdk::bitset<siz> operator >>(int x){
				hdk::bitset<siz> ans;
				for(int i=siz-1-x;i>=0;--i){
					ans.set(i,(*this)[i+x]);
				}
				return ans;
			}
	};
}