\(5.6\ NOI\)模拟
明天就母亲节了,给家里打了个电话(\(lj\ hsez\)断我电话的电,在宿舍打不了,只能用教练手机打了)
其实我不是很能看到自己的\(future,\)甚至看不到高三的希望,当然我不清楚我会被分到什么班(主要是停课前有几次考试考的很炸,最后一次才回到巅峰时期的一半,巅峰时期年级\(rk20-…\))
毕竟\(whk\)将近一年没学了(中间间歇性补了几次课),倒也能跟得上,但是也知道要真考试啥也不是,高三要分到一个氛围好的班级也很重要(啊喂,现在还没回高三,在这\(bb\)啥,现在这一阵子也是一直被这件事困扰了好长时间)
说实话,最差的结果也不是不能接受,毕竟选择都是自己选的,已经过去的再纠结也没用意义,困扰再久也没什么能解决的,但是最重要的是,把眼前的事情做好,一切结果就不会太差
家长说的是,珍惜好两个月,努力做好就好了(毕竟家长也只能鼓励了,真正要做事的还是自己)
不丧了,努力做好每一天就好了,现在想再多也改变不了过去,预测不了未来
而且,对于停课一年回归之后裸分\(T/P\)我还是有信心的(信心最重要了)
\(T1\)
尺取\(+\)正难则反\(+\)容斥
#include<bits/stdc++.h>
#define int long long
#define MAXN 2000005
using namespace std;
const int mod=1000000007;
int n,L,a[MAXN];
int res,res2,res3;
int my_pow(int a,int b)
{
int res=1;
while(b)
{
if(b&1)
{
res=(res*a)%mod;
}
a=(a*a)%mod;
b>>=1;
}
return res;
}
signed main()
{
scanf("%lld%lld",&n,&L);
if(n<=3)
{
cout<<0;
return 0;
}
for(int i=1;i<=n;i++)
{
scanf("%lld",&a[i]);
}
for(int i=1;i<=n;i++) a[i+n]=a[i]+L;
for(int i=2;i<=n;i++)
{
if(2*(a[i]-a[i-1])>L)
{
cout<<0;
return 0;
}
}
if(2*(a[n]-a[1])<L)
{
cout<<0;
return 0;
}
int ed=n,l=1,r=n;
while(r>1&&2*(a[ed]-a[r-1])<L) r--;
for(int i=1;i<=n;i++,ed++)
{
while(l+1<=2*n&&2*(a[l+1]-a[i])<L) l++;
while(r<=ed&&2*(a[ed]-a[r])>=L) r++;
int len=l-i;
res+=my_pow(2,len);
res%=mod;
if(l>=r)
{
res2+=my_pow(2,l-r+1)-(l-r+1);
res2%=mod;
res3+=(l-r);
}
else res3++;
}
res++;
res=(res*2-(res3+res2*2)+mod)%mod;
cout<<(my_pow(2,n)-res+mod)%mod*my_pow(my_pow(2,n),mod-2)%mod;
}
\(T2\)
每次操作相当于
将牌分成若干堆,对每堆进行降序排列,并把奇数堆内部翻转
考虑分治操作,取一个\(mid\)
每次将小于\(mid\)的看成\(0,\)大于\(mid\)的看成\(1\)
\(Step_1:\)我们对于目前序列的操作应当是,把所有的\(0\)合并到一起,把所有的\(1\)合并到一起
\(Step_2:\)将\(0/1\)部分递归下去分别排序
可能存在左右操作数不同的情况,导致并不是完全有序,那么就进行操作有序拼接
\(sol_1\):
可以按照\(00/1000/100/1\)
具体的分配方式就是
从后往前扫,每一块的形式大概是\(0011/1100,\)然后如果最后一块是奇数块的话就划分到倒数第二块里面(反正我想不出来,\(lyx\)就是聪明——来自校长的称赞)
操作上限\(\lfloor log(L+2) \rfloor\)
\(sol_2:\)
我们最后递归下去返回上来的可能是\(0011/1100,\)
也就是最后可能是\(3412/4312\)这样的形式
还是说,我们分治的过程是怎么保证整体序列的\(?\)
显然我们可以通过一些操作使得部分发生变化,只改变另外部分的相对顺序(我们在分组的时候保证了分偶数组)
那么就比较好说了,代码。。。
#include<bits/stdc++.h>
using namespace std;
int n,D,dat[100010];
bool cpy[100010];
vector<int>opt[200];
int wkot(int l,int r,int dep)
{
//开始分治,并记录深度,记录深度是为了同步
if(l==r)return dep;
int md=l+r>>1;
for(int i=l;i<=r;i++)
{
if(dat[i]<=md)
{
cpy[i]=false;
}
else
{
cpy[i]=true;
}
//小的赋值为0,大的赋值为1
}
while(true)
{
//SOL1的操作过程
int fr;
for(fr=l;fr<=md;fr++)
{
if(cpy[fr])goto EB;
}
break;
EB:
dep++;
//操作次数加一
for(int i=r;i>=fr;)
{
opt[dep].push_back(i);
//放入操作的端点
while(i>=fr&&cpy[i]==cpy[r])i--;
while(i>=fr&&cpy[i]!=cpy[r])i--;
}
if(opt[dep].size()&1)
{
opt[dep].push_back(fr-1);
//为了保证操作块数始终为偶数
//考虑是否把最后一段单独提出来
}
fr=l;int op=0;
for(vector<int>::reverse_iterator ite=opt[dep].rbegin();ite!=opt[dep].rend();ite++)
{
//简单操作,把代换序列和原序列全部翻转
if(*ite<l)break;//这个我没看见...
if(op)
{
reverse(cpy+fr,cpy+*ite+1);
reverse(dat+fr,dat+*ite+1);
}
op^=1;fr=*ite+1;
}
}
if(dat[md+1]!=md+1)
{
//把mid+1放到右边块的最左边
if(dat[r]==md+1)
{
//在下一层先把他放在最小值的位置
opt[++dep].push_back(md);
opt[dep].push_back(r);
reverse(dat+md+1,dat+r+1);
}
else if(dat[r-1]==md+1)
{
//先交换最右边两个
//后交换前面
opt[++dep].push_back(r-2);
opt[dep].push_back(r);
swap(dat[r],dat[r-1]);
opt[++dep].push_back(md);
opt[dep].push_back(r);
reverse(dat+md+1,dat+r+1);
}
else
{
for(int i=md+1;i<=r;i++)
{
if(dat[i]==md+1)
{
opt[++dep].push_back(md);
opt[dep].push_back(i);
opt[dep].push_back(r-1);
opt[dep].push_back(r);
reverse(dat+md+1,dat+i+1);
break;
}
}
}
}
int lr=wkot(l,md,dep),rr=wkot(md+1,r,dep);
if(lr<rr)
{
//深度不同的话,就搞成相同的,在每个操作里面都塞一个不影响状态的左边任意翻转就好了
for(int i=lr+1;i<=rr;i++)
{
opt[i].push_back(md-1);
opt[i].push_back(md);
}
}
else if(rr<lr)
{
//显然同理
for(int i=rr+1;i<=lr;i++)
{
opt[i].push_back(r-1);
opt[i].push_back(r);
}
}
return max(lr,rr);
}
int main()
{
scanf("%d%d",&n,&D);
for(int i=1;i<=n;i++)
{
cin>>dat[i];
}
int org;
for(org=2;org<=n;org++)
{
if(dat[org]==1)
{
reverse(dat+org,dat+n+1);
reverse(dat+1,dat+n+1);
//先把1,整到最左边
break;
}
}
int cn=wkot(1,n,0);
if(cn&1)
{
cn++;
for(int i=1;i<=n;i++)
{
opt[cn].push_back(i);
}
}
if(org<=n)
{
cn++;
printf("%d\n2 %d %d\n",cn,org-1,n-org+1);
cn--;
}
else
{
printf("%d\n",cn);
}
for(int i=1;i<=cn;i++)
{
sort(opt[i].begin(),opt[i].end());
if(i&1)
{
int lst=0;
printf("%d ",(int)opt[i].size());
for(vector<int>::iterator ite=opt[i].begin();ite!=opt[i].end();ite++)
{
printf("%d ",*ite-lst);
lst=*ite;
}
}
else
{
if(opt[i].size()<n)
{
printf("%d 0 ",(int)opt[i].size()+1);
//除了特殊情况,其余都提前塞一个0
//分奇偶整呗...考虑塞0或者不塞
}
else
{
printf("%d ",(int)opt[i].size());
}
for(vector<int>::reverse_iterator it=opt[i].rbegin(),ite=it+1;ite!=opt[i].rend();it=ite,ite++)
{
printf("%d ",*it-*ite);
}
printf("%d ",opt[i].front());
}
cout<<endl;
}
return 0;
}
\(T3\)
不会
