ZOJ Monthly, March 2013
A题
题目大意：给出一棵树，一开始节点值均为0，先要求完成在线操作：将某子树所有节点值取反，或者查询某子树总点权。
题解：很基础的线段树题，既然两个操作都是子树操作，那么就先树链剖分一下，将子树操作转变成线段树上的区间操作，区间翻转操作就等同于区间长度减去区间总权值，码量适中，水过。
#include <cstdio>
#include <algorithm>
#include <climits>
#include <cstring>
using namespace std;
const int N=500010;
char op[5];
int p[N],tot,x,d[N],num[N],ed=0,u,w,n,m,i,v[N],vis[N],f[N],g[N],nxt[N],size[N],son[N],st[N],en[N],dfn,top[N],t;char ch;
void add(int x,int y){v[++ed]=y;nxt[ed]=g[x];g[x]=ed;}
void dfs(int x){
size[x]=1;
for(int i=g[x];i;i=nxt[i])if(v[i]!=f[x]){
f[v[i]]=x,d[v[i]]=d[x]+1;
dfs(v[i]),size[x]+=size[v[i]];
if(size[v[i]]>size[son[x]])son[x]=v[i];
}
}
void dfs2(int x,int y){
if(x==-1)return;
st[x]=++dfn;top[x]=y;
if(son[x])dfs2(son[x],y);
for(int i=g[x];i;i=nxt[i])if(v[i]!=son[x]&&v[i]!=f[x])dfs2(v[i],v[i]);
en[x]=dfn;
}
struct node{int l,r,a,b,tag,val,len;}T[N];
void up(int x){T[x].val=T[T[x].l].val+T[T[x].r].val;}
void addtag(int x,int tag){
T[x].tag+=tag;
if(tag&1)T[x].val=(T[x].b-T[x].a+1)-T[x].val;
}
void pb(int x){
if(T[x].l){addtag(T[x].l,T[x].tag);addtag(T[x].r,T[x].tag);}
T[x].tag=0;
}
void build(int l,int r){
int x=++tot;
T[x].a=l;T[x].b=r;T[x].tag=T[x].l=T[x].r=T[x].val=0;
if(l==r)return;
int mid=(l+r)>>1;
T[x].l=tot+1;build(l,mid);
T[x].r=tot+1;build(mid+1,r);
}
void change(int x,int a,int b,int p){
if(T[x].a>=a&&T[x].b<=b){addtag(x,p);return;}
if(T[x].tag)pb(x); int mid=(T[x].a+T[x].b)>>1;
if(mid>=a&&T[x].l)change(T[x].l,a,b,p);
if(mid<b&&T[x].r)change(T[x].r,a,b,p);up(x);
}
int query(int x,int a,int b){
if(T[x].a>=a&&T[x].b<=b)return T[x].val;
if(T[x].tag)pb(x);int mid=(T[x].a+T[x].b)>>1,res=0;
if(mid>=a&&T[x].l)res+=query(T[x].l,a,b);
if(mid<b&&T[x].r)res+=query(T[x].r,a,b);
return res;
}
void init(){
memset(g,dfn=ed=tot=0,sizeof(g));
memset(v,0,sizeof(v));
memset(nxt,0,sizeof(nxt));
memset(son,-1,sizeof(son));
}
int main(){
while(~scanf("%d%d",&n,&m)){
init();
for(int i=2;i<=n;i++){
scanf("%d",&x);
add(x,i);add(i,x);
}dfs(1);dfs2(1,1);
build(1,dfn);
for(int i=1;i<=m;i++){
scanf(" %s%d",op,&x);
if(op[0]=='q')printf("%d\n",query(1,st[x],en[x]));
else change(1,st[x],en[x],1);
}puts("");
}return 0;
}
B题
题目大意：一门课的书有 N 章内容要复习，每天可以复习一章，但是有 M 个限制条件：一些功课不能在固定的天数复习，问方案数。
题解：限位排列，利用回溯的性质去重，然后用容斥原理计算即可。
#include <cstdio>
#include <algorithm>
using namespace std;
const int mod=55566677;
int m,n,a[25],b[25],va[60],C[60]={1},vb[60];
int GetAns(int x,int t){
if(x==m){
if(t%2)return(mod-C[n-t])%mod;
else return C[n-t];
}int tmp=GetAns(x+1,t);
if(!va[a[x]]&&!vb[b[x]]){
va[a[x]]=vb[b[x]]=1;
tmp=(tmp+GetAns(x+1,t+1))%mod;
va[a[x]]=vb[b[x]]=0;
}return tmp;
}
int main(){
for(int i=1;i<60;i++)C[i]=C[i-1]*1LL*i%mod;
while(~scanf("%d%d",&n,&m)){
for(int i=0;i<m;i++)scanf("%d%d",&a[i],&b[i]);
for(int i=0;i<m;i++)for(int j=i+1;j<m;j++){
if(a[i]==a[j]&&b[i]==b[j]){
swap(a[j],a[m-1]);
swap(b[j],b[--m]);
}
}printf("%d\n",GetAns(0,0));
}return 0;
}
C题
题目大意：一门课的书有 N 章内容要复习，每天可以复习一章，但是第 i 章不能在第 i 天或第 i + 1 天复习（最后一章则对应最后一天和第一天），问不同的复习方案数
题解：在棋盘格上将禁位逐行标号，那么禁位上的非重选取就是一个2n的圆排列中选取k个非相邻元素的排列组合问题，在禁位上的非重选取能够解决了之后就转化为容斥原理了。在计算的时候取模除法要注意计算乘法逆元。
#include <cstdio>
using namespace std;
typedef long long LL;
const int mod=1000000007;
int a[100005],r[100005];
int main(){
a[1]=a[2]=0; r[1]=a[3]=1;
for(int i=4;i<100005;i++){
r[i-2]=r[mod%(i-2)]*LL(mod-mod/(i-2))%mod;
a[i]=((i-2ll)*i%mod*a[i-1]%mod+(a[i-2]*LL(i)+(i&1?4:mod-4))%mod)*r[i-2]%mod;
}for(int n;~scanf("%d",&n);printf("%d\n",a[n]));
return 0;
}
D题
题目大意：古代某统治者要修建一些棺材，其中第 i 个棺材大小为 s[i]，修建需要花费 t[i] 天，如果在剩余 x 天的时候开始修建并且能够及时完成，则能获得 x * s[i] 的报酬，总共有 T 天可用，问最大能获得的报酬为多少
题解：Noip2012国王游戏的即视感，计算任意排列相邻两个棺材前后顺序对总报酬的影响，发现只与相邻两个棺材的s1*t2和s2*t1大小关系有关，于是按照这个条件排序，获得完成棺材的最佳顺序，由于时间的限制，棺材的修建可能不能全部完成，那么在既成的顺序上做一遍动态规划，一遍简单的01背包过后就能够获得答案了。
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
struct data{int t,v;}a[3005];
int dp[10005],n,T,ans;
bool cmp(data a,data b){return a.t*b.v<a.v*b.t;}
int main(){
while(~scanf("%d%d",&n,&T)){
memset(dp,0,sizeof(dp));ans=0;
for(int i=1;i<=n;i++)scanf("%d%d",&a[i].t,&a[i].v);
sort(a+1,a+n+1,cmp);
for(int i=1;i<=n;i++)
for(int j=T;j>=a[i].t;j--)dp[j]=max(dp[j],dp[j-a[i].t]+a[i].v*(T-j+a[i].t));
for(int i=1;i<=T;i++)ans=max(ans,dp[i]);
printf("%d\n",ans);
}return 0;
}
E题
题目大意：n 个人，每人各自从 1 到 m 中选出一个数字，相邻的两个人若是选择了同一个数字，那么该数字必须大于 k，求方案数
题解：对与每个人来说，如果上一个人选的数字小于等于k，如果他选取小于k的数，那么他只有k-1种选择，如果选择大于k的数，那么他有m-k种选择，如果上一个人选择的数字大于k，那么他选取小于k的数有k种选择，否则只有m-k种选择
a[i] = a[i - 1] * (k - 1) + b[i - 1] * k
b[i] = a[i - 1] * (m - k) + b[i - 1] * (m - k)
根据递推式构造矩阵，快速幂求解即可
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define mode 1000000007
typedef long long ll;
class Mart{
public:
int n,m;
ll data[5][5];
Mart(int a,int b){n=a;m=b;memset(data,0,sizeof(data));}
Mart mul(Mart b){
Mart a(n,b.m);
for(int i=0;i<n;i++)
for(int j=0;j<b.m;j++){
ll sum=0;
for (int k=0;k<m;k++)
sum=(sum%mode+data[i][k]%mode*(b.data[k][j]%mode))%mode;
a.data[i][j]=sum;
}
return a;
}
void print(){
for(int i=0;i<n;i++){
for(int j=0;j<m;j++)printf("%d ",data[i][j]);
printf("\n");
}
}
};
Mart Qm(Mart a,int e){
int n=a.n,m=a.m;
Mart c(n,m);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(i==j)c.data[i][j]=1;
while(e){
if(e&1)c=c.mul(a);
a=a.mul(a);
e=e>>1;
}return c;
}
int main(){
int m,k,n;
while(~scanf("%d%d%d",&n,&m,&k)){
Mart a(2,2);
a.data[0][0]=m-k;
a.data[0][1]=m-k;
a.data[1][0]=k;
a.data[1][1]=max(k-1,0);
a=Qm(a,n); Mart b(2,1);
b.data[0][0]=1;
b.data[1][0]=0;
a=a.mul(b);
ll ans=(a.data[0][0]%mode+a.data[1][0]%mode)%mode;
cout<<ans<<endl;
}return 0;
}
F题
题目大意：给出空间中的一些点，在这些位置上各有 F[i] 朵花，最多可以从这个位置移出 L[i] 朵花，问最小移动半径 R 是多少时，能够把所有位置上的花移动到位置 1（移动半径内的两个顶点可以完成花的直接移动）
题解：因为每个点都有限制移出的花朵数目，于是很自然地想到拆点，将每个顶点拆分为两个节点，点间设置流量上限为L[i]，现在要求最小的移动半径，使得该图满流。求最小代价使得目标达成这个条件非常的眼熟，代价最小化，那么二分答案，检验是否满流即可。
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const int N=30010,inf=~0U>>2;
const double EPS=1e-10;
struct edge{int t,f;edge*nxt,*pair;}*g[N],*d[N],pool[N],*cur=pool;
struct data{int x,y,z,f,l;}point[105];
int sum,cnt,cas,i,u,v,cost,n,m,S,T,h[N],gap[N],maxflow;
double l,r;
int min(int x,int y){return x<y?x:y;}
void add(int s,int t,int w){
//printf("%d %d %d\n",s,t,w);
edge*p=cur++;p->t=t;p->f=w;p->nxt=g[s];g[s]=p;
p=cur++;p->t=s;p->f=0;p->nxt=g[t];g[t]=p;
g[s]->pair=g[t];g[t]->pair=g[s];
}
int sap(int v,int flow){
if(v==T)return flow;
int rec=0;
for(edge*p=d[v];p;p=p->nxt)if(h[v]==h[p->t]+1&&p->f){
int ret=sap(p->t,min(flow-rec,p->f));
p->f-=ret;p->pair->f+=ret;d[v]=p;
if((rec+=ret)==flow)return flow;
}if(!(--gap[h[v]]))h[S]=T;
gap[++h[v]]++;d[v]=g[v];
return rec;
}
double cal(data a,data b){
return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z);
}
int check(double x){
maxflow=0; int base=n+1;
for(cur=pool,i=(S=1);i<=(T=base+n+1);i++)g[i]=d[i]=NULL,h[i]=gap[i]=0;
point[base].l=inf;
for(i=2;i<=n+1;i++)add(S,i,point[i].f);
for(i=2;i<=n+1;i++)add(i,i+base,point[i].l);
for(i=2;i<=n;i++)for(int j=i+1;j<=n+1;j++){
if(cal(point[i],point[j])<x*x){
add(base+i,j,inf);
add(base+j,i,inf);
}
}for(gap[0]=T,i=1;i<=T;i++)d[i]=g[i];
while(h[S]<T)maxflow+=sap(S,inf);
return(maxflow==sum);
}
int main(){
while(~scanf("%d",&n)){
sum=0;
for(int i=n+1;i>1;i--){
scanf("%d%d%d%d%d",&point[i].x,&point[i].y,&point[i].z,&point[i].f,&point[i].l);
sum+=point[i].f;
}r=100000,l=0;
while(fabs(l-r)>EPS){
double mid=(l+r)/2;
if(check(mid))r=mid;
else l=mid;
}if(r==100000)puts("-1");
else printf("%.8lf\n",r);
}return 0;
}
G题
题目大意：n 个人排成一排，每个人有两个值 rp[i] 和 gf[i]，现要把这 n 个人划分成若干段，要求各段的 max(rp) 加起来不超过 Rlimit，并使得最大的 gf子段和 最小
题解：别的不说看到gf分段和，那么就先算个gf的前缀和s备用，最大的gf子段和最小，眼熟，相当眼熟，又是二分答案，那么就是验证在每段的gf值不超过mid的情况下是否可以做到各段最大值之和不超过Rlimit，检验的dp方程很显然
dp[i+1]=rp_max+dp[j](gf[i,j]<=mid)
观察到rp在选取时，只有单调递减的rp值在会有决策意义，于是可以用单调队列优化dp，减少无意义的决策。
在更新dp值的时候，队列中dp[q[k]] + rp[q[k+1]]也是需要被考虑到的，所以同时用平衡树维护队列中元素的插入删除和最小值查询。
#include <cstdio>
#include <queue>
#include <set>
#include <algorithm>
using namespace std;
const int N=40005;
int n,m;
int s[N],gf[N],rp[N],dp[N];
multiset<int> S;
void pop_back(deque<int>& u){
if(u.size()>1)S.erase(S.find(dp[u[u.size()-2]+1]+rp[u.back()]));
u.pop_back();
}
void pop_front(deque<int>& u){
if(u.size()>1)S.erase(S.find(dp[u.front()+1]+rp[u[1]]));
u.pop_front();
}
bool check(int x){
S.clear();
deque<int>u;
for(int i=0,j=0;i<n;i++){
while(s[i+1]-s[j]>x)j++;
while(u.size()&&u.front()<j)pop_front(u);
while(u.size()&&rp[u.back()]<=rp[i])pop_back(u);
u.push_back(i);
if(u.size()>1)S.insert(dp[u[u.size()-2]+1]+rp[u.back()]);
dp[i+1]=rp[u.front()]+dp[j];
if(S.size())dp[i+1]=min(*S.begin(),dp[i+1]);
}return dp[n]<=m;
}
int main(){
while(~scanf("%d%d",&n,&m)){
for(int i=0;i<n;i++){
scanf("%d%d",&rp[i],&gf[i]);
s[i+1]=s[i]+gf[i];
}int l=*max_element(gf,gf+n),r=s[n];
while(l<r){
int mid=(l+r)/2;
if(check(mid))r=mid;
else l=mid+1;
}printf("%d\n",l);
}return 0;
}
H题
题目大意：ZJU ACM ICPC 暑假集训结束，为了庆祝这兴奋的一刻，教练 Navi 和 Fancy 决定 BG 参加集训的 N 个小朋友们。他们去了楼外楼吃自助，每个人要花费 W 元，但每 K 个人可以免费一个人，Navi 和 Fancy 会平摊此次 BG 的花销，问他们俩每人要支付多少钱
题解：H题作为签到题，还是有一定水准的，注意是N+2个人去吃饭，注意W是小数，同时注意精度存在误差，需要EPS。
#include <cstdio>
double w;
double eps=1e-6;
int n,k,t,ans;
int main(){
while(~scanf("%d%lf%d",&n,&w,&k)){
n+=2; t=n/k;
ans=100*(n-t)*(w+eps);
ans=(ans+1)/2;
printf("%d.%02d\n",ans/100,ans%100);
}return 0;
}
I题
题目大意：有一个数列，要求选出 M 个区间，每个区间长度在 [L, R] 内，使得选出的那些数字的平均值尽可能大
题解：分数规划，每次将数组中的数减去求出平均值，做一次动态规化，根据结果重新调整自己的选择，迭代计算直到结果最优。
需要特别注意的是负数的取整是要上取整的，在计算答案的时候要特殊处理。
#include <cstdio>
#include <cstring>
#include <deque>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL INF=1000000000000000007ll;
typedef pair<int,LL> PIL;
int n,m,l,r,a[100005];
LL dp[15][100005],sum[100005],pfx[100005];
PIL pt[15][100005];
bool check(LL&S,LL&N){
for(int i=0;i<n;i++)sum[i+1]=sum[i]+a[i]*N-S;
for(int x=1;x<=m;x++){
dp[x][0]=-INF;
deque<PIL>u;
for(int i=1;i<=n;i++){
while(u.size()&&i-u.front().first>r)u.pop_front();
int k=i-l;
if(k>=0&&dp[x-1][k]!=-INF){
LL tmp=dp[x-1][k]-sum[k];
while(u.size()&&tmp>u.back().second)u.pop_back();
u.push_back(PIL(k,tmp));
}dp[x][i]=dp[x][i-1],pt[x][i]=pt[x][i-1];
if(u.size()){
int pos=u.front().first;
LL tmp=u.front().second+sum[i];
if(tmp>dp[x][i]){
dp[x][i]=tmp;
pt[x][i]=pt[x-1][pos];
pt[x][i].first+=i-pos;
pt[x][i].second+=pfx[i]-pfx[pos];
}
}
}
}if(!dp[m][n])return 1;
return N=pt[m][n].first,S=pt[m][n].second,0;
}
LL GetAns(LL S,LL N){
if(S>=0)return S/N;
return -((-S+N-1)/N);
}
int main(){
while(~scanf("%d%d%d%d",&n,&m,&l,&r)){
for(int i=0;i<n;i++){scanf("%d",&a[i]);pfx[i+1]=pfx[i]+a[i];}
LL S=0,N=1;
while(N&&!check(S,N));
if(!N){puts("-1");}
else{
LL ans=GetAns(S*100,N);
printf("%lld.%02lld\n",ans/100,abs(ans)%100);
}
}return 0;
}
J题
题目大意：植物大战肥羊，现在有一大波肥羊入侵，地图中有的地方肥羊不能走，有的地方通过需要一秒，有的地方通过需要两秒，有的地方可以放置植物防御（神奇的塔防游戏），然后你现在有两种植物可以种植：一种是可以攻击一整行肥羊的植物，但是只能朝向一个方向，而且确定方向之后就不能改，一种是范围攻击，能攻击到一定曼哈顿距离内的肥羊，这两种植物还可以升级，升级之后能加伤害，当然升级也需要一定的费用，肥羊在入侵的时候，会选择最短路，现在告诉你每只肥羊入侵的时间和血量，求最佳布防，即在防御肥羊的情况下消耗最小
题解：首先，肥羊的入侵是最短路，所以，路线是确定的，那么我们广搜一下记录路径，对于每个可以设置塔防的位置，我们分别计算每种植物的伤害和代价，伤害怎么来的？就是肥羊在他攻击范围的滞留时间乘上单位时间的伤害，那么根据保存路径算出滞留时间就好了。
可是那么多肥羊，该怎么处理呢，嘛，其实既然他们路线是一样的，植物又是群体攻击，那么只要能防御血量最多的肥羊，就能防御所有的肥羊了，好咯，现在有伤害值，和代价值，要求总伤害达到阈值。怎么做？分组背包问题。复杂的塔防问题迎刃而解。
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
typedef pair<int,int> PII;
typedef pair<PII,int> TPL;
#define mp make_pair
const int mr[]={0,-1,1,0},mc[]={1,0,0,-1};
char a[35][35];
bool v[35][35];
int n,m,p,dp[35][35],tim[9][35][35],hp[1024],at[1024],w[1025];
bool check(int x,int y){return(x>=1&&y>=1&&x<=n&&y<=m&&v[x][y]);}
int main(){
while(~scanf("%d%d%d",&n,&m,&p)){
int sr=0,sc=0,tr=0,tc=0;
for(int i=1;i<=n;i++){
scanf("%s",a[i]+1);
for(int j=1;j<=m;j++){
if(a[i][j]=='s')a[sr=i][sc=j]='.';
if(a[i][j]=='t')a[tr=i][tc=j]='.';
}
}for(int i=0;i<p;i++)scanf("%d",&hp[i]);
for(int i=0;i<p;i++)scanf("%d",&at[i]);
int V=*max_element(hp,hp+p); queue<PII> q;
memset(dp,63,sizeof(dp)); dp[tr][tc]=1;
memset(v,0,sizeof(v));
for(q.push(mp(tr,tc));q.size();q.pop()){
int r=q.front().first,c=q.front().second;
v[r][c]=0;
for(int o=0;o<4;o++){
int dr=r+mr[o],dc=c+mc[o];
if(!dr||!dc||dr>n||dc>m||a[dr][dc]=='x'||a[dr][dc]=='k')continue;
int cost=dp[r][c]+(a[dr][dc]=='w')+1;
if(cost<dp[dr][dc]){
dp[dr][dc]=cost;
if(!v[dr][dc]){v[dr][dc]=1;q.push(mp(dr,dc));}
}
}
}memset(v,0,sizeof(v));
while(1){
v[sr][sc]=true;
if(sr==tr&&sc==tc)break;
for(int o=0;o<4;o++){
int dr=sr+mr[o],dc=sc+mc[o];
if(!dr||!dc||dr>n||dc>m||a[dr][dc]=='x'||a[dr][dc]=='k')continue;
int cost=dp[sr][sc]-(a[sr][sc]=='w')-1;
if(cost==dp[dr][dc]){sr=dr,sc=dc;break;}
}
}memset(tim,0,sizeof(tim));
for(int i=1;i<=n;i++) for(int j=1;j<=m;j++)if(a[i][j]=='k'){
for(int l=1;l<9;l++){
tim[l][i][j]=tim[l-1][i][j];
for(int x=0;x<l;x++){
if(check(i+x,j+l-x))tim[l][i][j]+=(a[i+x][j+l-x]=='w')+1;
if(check(i+l-x,j-x))tim[l][i][j]+=(a[i+l-x][j-x]=='w')+1;
if(check(i-x,j-l+x))tim[l][i][j]+=(a[i-x][j-l+x]=='w')+1;
if(check(i-l+x,j+x))tim[l][i][j]+=(a[i-l+x][j+x]=='w')+1;
}
}tim[0][i][j]=0;
for(int o=0;o<4;o++){
int dr=i,dc=j,now=0;
while(1){
dr+=mr[o];dc+=mc[o];
if(!dr||!dc||dr>n||dc>m||a[dr][dc]=='x'||a[dr][dc]=='k')break;
if(v[dr][dc])now+=(a[dr][dc]=='w')+1;
}tim[0][i][j]=max(tim[0][i][j],now);
}
}int R1,S1,T1,U1,V1,W1,L1,R2,S2,T2,U2,V2,W2,L2,X2;
scanf("%d%d%d%d%d%d%d",&R1,&S1,&T1,&U1,&V1,&W1,&L1);
scanf("%d%d%d%d%d%d%d%d",&R2,&S2,&T2,&U2,&V2,&W2,&L2,&X2);
memset(w,63,sizeof(w));w[0]=0;
for(int i=1;i<=n;i++)for(int j=1;j<=m;j++)if(a[i][j]=='k'){
vector<PII> u;
for(int x=0;x<L1;x++)u.push_back(mp(R1+U1*x,(T1+W1*x)*(S1+V1*x)*tim[0][i][j]));
for(int x=0;x<L2;x++)u.push_back(mp(R2+U2*x,(T2+W2*x)*(S2+V2*x)*tim[X2][i][j]));
for(int c=V;c;c--){
for(int x=0;x<u.size();x++)
w[c]=min(w[c],w[max(c-u[x].second,0)]+u[x].first);
}
}if(w[V]>1000000000) puts("Happy summer holiday!");
else printf("%d\n",w[V]);
}return 0;
}
就快要省赛了，要更努力一些了，队友说的话还是很有道理的，人还是要有梦想的，万一实现了呢。
所以，竭尽全力。
ZOJ Monthly, March 2013的更多相关文章
- ZOJ 4010 Neighboring Characters（ZOJ Monthly, March 2018 Problem G，字符串匹配）
题目链接 ZOJ Monthly, March 2018 Problem G 题意 给定一个字符串.现在求一个下标范围$[0, n - 1]$的$01$序列$f$.$f[x] = 1$表示存在一种 ...
- ZOJ 4009 And Another Data Structure Problem（ZOJ Monthly, March 2018 Problem F，发现循环节 + 线段树 + 永久标记）
题目链接 ZOJ Monthly, March 2018 Problem F 题意很明确 这个模数很奇妙,在$[0, mod)$的所有数满足任意一个数立方$48$次对$mod$取模之后会回到本身. ...
- ZOJ Monthly, March 2018 题解
[题目链接] A. ZOJ 4004 - Easy Number Game 首先肯定是选择值最小的 $2*m$ 进行操作,这些数在操作的时候每次取一个最大的和最小的相乘是最优的. #include & ...
- ZOJ Monthly, March 2018 Solution
A - Easy Number Game 水. #include <bits/stdc++.h> using namespace std; #define ll long long #de ...
- ZOJ Monthly, March 2018
A. Easy Number Game 贪心将第$i$小的和第$2m-i+1$小的配对即可. #include<cstdio> #include<algorithm> usin ...
- 浙大月赛ZOJ Monthly, August 2014
Abs Problem Time Limit: 2 Seconds Memory Limit: 65536 KB Special Judge Alice and Bob is playing a ga ...
- 135 - ZOJ Monthly, August 2014
135 - ZOJ Monthly, August 2014 A:构造问题,推断序列奇偶性.非常easy发现最小值不是1就是0.最大值不是n就是n - 1,注意细节去构造就可以 E:dp.dp[i][ ...
- 思维+multiset ZOJ Monthly, July 2015 - H Twelves Monkeys
题目传送门 /* 题意:n个时刻点,m次时光穿梭,告诉的起点和终点,q次询问,每次询问t时刻t之前有多少时刻点是可以通过两种不同的路径到达 思维:对于当前p时间,从现在到未来穿越到过去的是有效的值,排 ...
- ZOJ Monthly, October 2010 ABEFI
ZOJ 3406 Another Very Easy Task #include <cstdio> #include <cstring> const int N = 10000 ...
随机推荐
- Linux学习之traceroute命令
通过traceroute我们可以知道信息从你的计算机到互联网另一端的主机是走的什么路径.当然每次数据包由某一同样的出发点(source)到达某一同样的目的地(destination)走的路径可能会不一 ...
- JVM学习之Eclipse输出GC日志
Java应用启动时,可以通过设置verbose参数来输出JVM的gc情况,命令如下:-verbose:gc或者-XX:+PrintGC在Eclipse中可以通过Run As|Run Configura ...
- Android Shape画圆，矩形
画圆环代码如下: 画圆环,外边的边界宽度大一点即可: <?xml version="1.0" encoding="utf-8"?> <shap ...
- MyEclipse数据库反向生成实体类
MyEclipse数据库反向生成实体类 “计应134(实验班) 凌豪” 当我们在开发项目涉及到的表太多时,一个一个的写JAVA实体类很是费事.然而强大的MyEclipse为我们提供简便的方法:数据库反 ...
- 编写一个程序实现strlen函数的功能
写自己的 strlen 函数-----→ mystrlen #include <stdio.h> #include <string.h> #define N 100 int m ...
- Orchard 源码探索（Localization）之国际化与本地化
本地化与国际化 基本上相关代码都在在Orchard.Framework.Localization中. T("english")是如何调用到WebViewPage.cs中的Local ...
- Top free and open source log management software
As mentioned in the previous post, in my quest to find an alternative to Kiwi Syslog, I looked at a ...
- Krita编译和旧版本下载
Linux For Krita 2.9, David Revoy's guide Building Krita for Cats is the best available! Build Krita ...
- mac下通过xcodebuild使用oclint
step1 :下载oclint并安装 下载地址: http://oclint.org/downloads.html 选择mac os x或者darwin的包,下载到本地. 文件夹类似以下: oclin ...
- hdu 2102 A计划（双层BFS）（具体解释）
转载请注明出处:http://blog.csdn.net/u012860063?viewmode=contents 题目链接:http://acm.hdu.edu.cn/showproblem.php ...