乱搞Word格式文档下载.docx
《乱搞Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《乱搞Word格式文档下载.docx（42页珍藏版）》请在冰豆网上搜索。
>
L>
b>
f）{
st.clear（）;
st.insert（-b）;
st.insert（L+f）;
scanf（"
%d"
&
n）;
for（intcas=1;
cas<
=n;
cas++）{
%d%d"
k,&
x）;
if（k==1）{
intok=1;
for（ita=st.begin（）;
ita!
=st.end（）;
ita++）{
itb=ita;
itb++;
if（itb!
=st.end（）&
&
*ita+b+x+f<
=*itb）{
car[cas]=make_pair（*ita+b,*ita+b+x）;
st.insert（car[cas].first）;
st.insert（car[cas].second）;
ok=0;
printf（"
%d\n"
car[cas].first）;
break;
}
ita++;
if（ok）puts（"
-1"
）;
else{
st.erase（car[x].first）;
st.erase（car[x].second）;
return0;
}
xiyizi,xi必选，[yizi]选1个，最少
typedefpair<
PII;
intcmp（PIIa,PIIb）{
if（a.y!
=b.y）returna.y<
b.y;
elsereturna.x<
b.x;
PIIpt[maxn];
inta[maxn],A[maxn];
intm;
vector<
PII>
g;
inthave（PII&
p,intc）{
inti=lower_bound（a,a+m,p.x）-a;
if（a[i]==c）i++;
if（i<
m&
a[i]<
=p.y）return1;
intt,n;
cin>
t;
=t;
for（inti=0;
i<
n;
i++）{
%d%d%d"
&
a[i],&
pt[i].x,&
pt[i].y）;
A[i]=a[i];
sort（a,a+n）;
m=unique（a,a+n）-a;
g.clear（）;
if（!
have（pt[i],A[i]））g.push_back（pt[i]）;
intans=m;
sort（g.begin（）,g.end（）,cmp）;
intpos=0;
g.size（）;
if（g[i].x>
pos）{
pos=g[i].y;
ans++;
Case#%d:
%d\n"
cas,ans）;
首先求系数矩阵。
由每个数的范围可以确定每个数转化成二进制以后最多有63位，那么我们构造一个63*100的矩阵，a[i][j]表示第j个数的第i个二进制位，因为我们想要结构最大，最后一列置为1，然后用高斯消元判断每一行即想要结果的每一位能不能取得1。
从高位向低位，判断每一行是否有可控制变元（是否有1），如果有那么这一行可以取得1，同时从该行往下依次异或掉该列不为0的行，即异或掉该变元。
如果没有可控制的变元，但是最后一列是0，该行结构也是1，若最后一列不为0说明该行结果为0。
从高位向低位，每次确定了一位后，就更新ans的值，最后取得一个最大值。
inta[65][110];
intn;
voidGauss（）{
intx;
LLans=0;
for（inti=0;
63;
x=-1;
for（intj=0;
j<
n;
j++）{
if（a[i][j]）{
x=j;
//找到一个可控制的变元
break;
}
}
//若没找到，但最后一列为0，该行结果是1
if（x==-1&
a[i][n]==0）{
ans+=（1ll<
<
（62-i））;
//若找到了一个控制变元
elseif（x!
=-1）{
ans+=（1ll<
//从该行一下异或该变元
for（intj=i+1;
j++）
if（a[j][x]）{
for（intk=0;
k<
=n;
k++）
a[j][k]^=a[i][k];
}
cout<
ans<
endl;
LLx;
&
n）;
memset（a,0,sizeof（a））;
scanf（"
%lld"
x）;
if（x&
（1ll<
（62-j）））
a[j][i]=1;
i++）
a[i][n]=1;
Gauss（）;
return0;
比如（2，4，4，1）和（33，57，57，2）匹配
constintmaxn=100008;
intNext[maxn];
inta[maxn],b[maxn];
intsa[maxn][26],sb[maxn][26];
intn,m,k;
intok1（inti,intj）{
intl1,l2,e1,e2;
l1=l2=e1=e2=0;
for（intt=1;
t<
=k;
t++）{
if（t<
b[i]）
l1+=sb[i][t]-sb[i-j][t];
elseif（t==b[i]）
e1+=sb[i][t]-sb[i-j][t];
b[j]）
l2+=sb[j][t];
e2+=sb[j][t];
returnl1==l2&
e1==e2;
intok2（inti,intj）{
a[i]）
l1+=sa[i][t]-sa[i-j][t];
elseif（t==a[i]）
e1+=sa[i][t]-sa[i-j][t];
elseif（t==b[j]）
voidgetNext（）{
inti,j;
j=0;
Next[1]=0;
for（i=2;
i<
=m;
i++）{
while（j>
0&
!
ok1（i,j+1））
j=Next[j];
if（ok1（i,j+1））
j++;
Next[i]=j;
intkmp（）{
intcnt=0;
//初始状态为0
for（i=1;
=n;
ok2（i,j+1））
if（ok2（i,j+1））
if（j==m）{
cnt++;
j=0;
//特殊处理一下
returncnt;
intmain（）{
inti,j;
n>
m>
k）{
memset（sa,0,sizeof（sa））;
memset（sb,0,sizeof（sb））;
for（i=1;
a[i]）;
for（j=1;
j++）sa[i][j]=sa[i-1][j];
sa[i][a[i]]++;
=m;
b[i]）;
j++）sb[i][j]=sb[i-1][j];
sb[i][b[i]]++;
getNext（）;
kmp（））;
typedeflonglongLL;
constintmaxn=2008;
LLdp[maxn],h[maxn];
int_stack[maxn],top;
intgetidx（inti）{
while（top>
=0&
h[_stack[top]]>
=h[i]）top--;
_stack[++top]=i;
if（top>
0）return_stack[top-1];
elsereturn0;
intn,m;
charstr[maxn];
LLsum;
m）{
sum=0;
memset（h,0,sizeof（h））;
memset（dp,0,sizeof（dp））;
while（n--）{
%s"
str+1）;
top=-1;
for（inti=1;
if（str[i]=='
w'
）h[i]++;
elseh[i]=0;
intj=getidx（i）;
dp[i]=dp[j]+h[i]*（i-j）;
sum+=dp[i];
cout<
sum<
endl;
inta[maxn],n;
intcmax[maxn][20],cmin[maxn][20],tlog[maxn];
voidrmqinit（）{
i++）cmax[i][0]=cmin[i][0]=a[i];
for（intj=1;
（1<
j）<
i+（1<
j）-1<
cmax[i][j]=std:
max（cmax[i][j-1],cmax[i+（1<
（j-1））][j-1]）;
cmin[i][j]=std:
min（cmin[i][j-1],cmin[i+（1<
tlog[0]=tlog[1]=0;
for（inti=2;
i++）tlog[i]=tlog[i>
1]+1;
intrmqmax（intl,intr）{
inti=tlog[r-l+1];
returnstd:
max（cmax[l][i],cmax[r-（1<
i）+1][i]）;
intrmqmin（intl,intr）{
min（cmin[l][i],cmin[r-（1<
std:
pt[maxn];
intk,i,l,r,m,mxlen;
i++）scanf（"
rmqinit（）;
l=r=1;
m=mxlen=0;
while
（1）{
if（rmqmax（l,r）-rmqmin（l,r）<
=k）{
if（r-l+1>
mxlen）{
mxlen=r-l+1;
m=0;
pt[++m]=std:
make_pair（l,r）;
elseif（r-l+1==mxlen）
r++;
elsel++;
while（l>
r）r++;
if（r>
n）break;
%d%d\n"
mxlen,m）;
i++）printf（"
pt[i].first,pt[i].second）;
求最小的容量
依次给出1-M的靶子
需要编号为Ai的箭，初始箭袋为空
1、如果箭在袋子里，射靶子，然后再把箭放在袋子里
2、如果箭不在袋子里，花1分钟时间，然后再射靶子，再把箭放在袋子里。
3、如果袋子的箭数量>
“容量”了，保留最近使用的“容量”支箭。
intn,M,CCtime;
inta[maxn];
constintinf=100000000;
structItem{
intid;
inttim;
Item（）{};
Item（int_id,int_tim）:
id（_id）,tim（_tim）{};
friendbooloperator<
（constItem&
a,constItem&
b）{
returna.tim>
b.tim;
};
intvis[maxn];
intjudge（intCap）{
inttim=0;
fill（vis,vis+1+n,inf）;
priority_queue<
Item>
que;
intqsize=0;
=M;
intid=vis[a[i]];
if（id!
=inf）{
que.push（Item（a[i],i））;
vis[a[i]]=i;
continue;
if（++tim>
CCtime）return0;
if（qsize<
Cap）{
qsize++;
elseif（qsize==Cap）{
while（!
que.empty（））{
Itemit=que.top（）;
if（it.tim!
=vis[it.id]）que.pop（）;
elsebreak;
if（it.tim==vis[it.id]）que.pop（）;
vis[it.id]=inf;
return1;
intgao（）{
intl=1,r=M,s=-1,mid;
while（l<
=r）{
mid=（l+r）>
1;
if（judge（mid））{
s=mid;
r=mid-1;
elsel=mid+1;
returns;
intt;
while（t--）{
n,&
M,&
CCtime）;
gao（））;
constintmaxn=1000008;
intnext[maxn];
voidgetnext（chars[]）{
intlen=strlen（s）;
next[0]=-1;
inti=0,j=-1;
while（i<
len）{
if（j==-1||s[i]==s[j]）next[++i]=++j;
elsej=next[j];
charword[maxn];
intx[maxn];
constLLmod=1000000007LL;
LLPow（LLx,inty）{
LLs=1;
for（;
y;
y>
=1）{
if（y&
1）{
s*=x;
s%=mod;
x*=x;
x%=mod;
intn,m,len;
LLans（）{
if（m==0）returnPow（26LL,n）;
LLsum=Pow（26LL,x[1]-1）;
if（x[i]-x[i-1]>
=len）{
sum*=Pow（26LL,x[i]-x[i-1]-len）;
sum%=mod;
if（st.find（x[i]-x[i-1]+1）==st.end（））return0;
sum*=Pow（26LL,n-x[m]-len+1）;
returnsum;
word）;
getnext（word）;
x[i]）;
len=strlen（word）;
inti=len;
while（next[i]!
=0）{
st.insert（len-next[i]+1）;
i=next[i];
ans（）<
给你一个n位数，每次操作可以选该数任意的相邻两位进行交换，如果最多可以操作k次,那么最终可以得到的最小的数是什么.
（n位且不能含前导零）？
char
升级会员 