A.Parenthesis
括号匹配的问题有一种经典的做法。
将左括号看成1，右括号看成-1，做一遍前缀和sum。
括号序列是合法的当且仅当\(sum[n]=Min(sum[1],sum[2]....sum[n])=0\)时成立。
于是问题变成了交换两个括号后如何维护sum数组的值。
实际上交换a和b之后只会影响到\((sum[a],sum[a+1]....sum[b-1])\)。
1.\(s[a]=(,s[b]=)\) 对应的区间减2。
2.\(s[a]=),s[b]=(\) 对应的区间加2。
我们只需要维护一个支持区间查询最小值，区间加减的数据结构即可。
显然线段树可以完成这些操作。时间复杂度\(O(qlogn)\)
# include <bits/stdc++.h>
using namespace std;
const int N=100005;
int sum[N], seg[N<<3], tag[N<<3];
char s[N];
void push_up(int p){seg[p]=min(seg[p<<1],seg[p<<1|1]);}
void push_down(int p){
if (!tag[p]) return ;
seg[p]+=tag[p]; tag[p<<1]+=tag[p]; tag[p<<1|1]+=tag[p]; tag[p]=0;
}
void init(int p, int l, int r){
if (l<r) {
int mid=(l+r)>>1;
init(p<<1,l,mid); init(p<<1|1,mid+1,r); push_up(p);
}
else seg[p]=sum[l], tag[p]=0;
}
void update(int p, int l, int r, int L, int R, int val){
push_down(p);
if (L>r||R<l) return ;
if (L<=l&&R>=r) tag[p]+=val, push_down(p);
else {
int mid=(l+r)>>1;
update(p<<1,l,mid,L,R,val); update(p<<1|1,mid+1,r,L,R,val); push_up(p);
}
}
int main ()
{
int n, q, l, r;
while (~scanf("%d%d",&n,&q)) {
scanf("%s",s+1);
for (int i=1; i<=n; ++i) sum[i]=sum[i-1]+(s[i]=='('?1:-1);
init(1,1,n);
while (q--) {
scanf("%d%d",&l,&r);
if (l>r) swap(l,r);
if (s[l]!=s[r]) {
if (s[l]=='(') update(1,1,n,l,r-1,-2);
else update(1,1,n,l,r-1,2);
}
puts(seg[1]==0?"Yes":"No");
if (s[l]!=s[r]) {
if (s[l]=='(') update(1,1,n,l,r-1,2);
else update(1,1,n,l,r-1,-2);
}
}
}
return 0;
}
B.权势二进制
题目可以换一种描述。
给出n，问至少可以表示为多少个数位上面只有0和1的数字之和。
显然答案即为n的十进制数位的最大值，即\(max(n\%10,n\%100,n\%1000....)\)
时间复杂度\(O(logn)\)。
# include <bits/stdc++.h>
using namespace std;
char s[10];
int main ()
{
int ans=0;
scanf("%s",s);
for (int i=0; s[i]; ++i) ans=max(ans,s[i]-'0');
printf("%d\n",ans);
return 0;
}
C.天气晴朗的魔法
如果不考虑边权的最大值最小的话，答案就是最大生成树。
现在要求图的生成树中边权的最大值最小。
实际上由Kruskal的算法流程可知，这个值就是图的最小生成树的最大边，不可能比这更小了。
因此，先对图求一遍最小生成树，获得这个最大值，然后把小于等于这个最大值的边
拉出来再求一遍最大生成树，显然即为答案。
时间复杂度\(O(mlogm)\)。
# include <bits/stdc++.h>
using namespace std;
const int N=200005;
struct Edge{int u, v, w;}edge[N];
int n, m, F[N];
long long ans=0;
int find(int x){return F[x]==0?x:F[x]=find(F[x]);}
bool comp(Edge a, Edge b){return a.w<b.w;}
void Kruskal(){
sort(edge+1,edge+m+1,comp);
int Max_w;
for (int i=1; i<=m; ++i) {
int u=find(edge[i].u), v=find(edge[i].v);
if (u==v) continue;
F[u]=v; Max_w=edge[i].w;
}
memset(F,0,sizeof(F));
for (int i=m; i>=1; --i) {
if (edge[i].w>Max_w) continue;
int u=find(edge[i].u), v=find(edge[i].v);
if (u==v) continue;
F[u]=v; ans+=edge[i].w;
}
}
int main ()
{
scanf("%d%d",&n,&m);
for (int i=1; i<=m; ++i) scanf("%d%d%d",&edge[i].u,&edge[i].v,&edge[i].w);
Kruskal();
printf("%lld\n",ans);
return 0;
}
D.大鱼吃小鱼
用栈来进行模拟，向右边走的鱼入栈，左边走的鱼和栈顶的鱼进行比较，
如果左边走的鱼比栈顶的鱼体积小，那么就会被吃掉。
否则吃掉栈顶的鱼继续和栈顶的下一个鱼进行比较，直到被吃掉或者栈为空为止。
模拟过程中一共多少鱼会被吃掉，最后拿总数减去它即可答案。
时间复杂度\(O(n)\)。
# include <bits/stdc++.h>
using namespace std;
const int N=100005;
int st[N], top=0;
int main ()
{
int n, a, b, sum=0;
scanf("%d",&n);
for (int i=1; i<=n; ++i) {
scanf("%d%d",&a,&b);
if (b==1) st[++top]=a;
else {
while (top&&st[top]<a) --top, ++sum;
if (top) ++sum;
}
}
printf("%d\n",n-sum);
return 0;
}
E.0和1相等串
将0写成-1，对原序列做一遍前缀和sum。
那么区间\([l,r]\)的0和1出现次数相等的充分必要条件为\(sum[r]=sum[l-1]\)。
现在要找到最大的\(r-l+1\)使得\(sum[r]=sum[l-1]\)。
我们扫一遍sum数组，记录每个val对应的\(sum[i]=val\)的下标i的最大值\(i_{max}\)和最小值\(i_{min}\)。那么这个val对应的答案就是\(i_{max}-i_{min}\)。
对所有val的答案取最大值即可。
时间复杂度\(O(len)\)
# include <bits/stdc++.h>
using namespace std;
const int N=1000005;
int sum[N], Min_p[N<<1], Max_p[N<<1];
char s[N];
const int P=1000000;
int main ()
{
scanf("%s",s+1);
int n=strlen(s+1);
memset(Min_p,-1,sizeof(Min_p)); memset(Max_p,-1,sizeof(Max_p));
for (int i=1; i<=n; ++i) sum[i]=sum[i-1]+(s[i]=='1'?1:-1);
for (int i=0; i<=n; ++i) {
int x=sum[i];
if (Min_p[x+P]==-1) Min_p[x+P]=i;
}
for (int i=n; i>=0; --i) {
int x=sum[i];
if (Max_p[x+P]==-1) Max_p[x+P]=i;
}
int ans=0;
for (int i=0; i<=n+P; ++i) if (Min_p[i]!=-1) ans=max(ans,Max_p[i]-Min_p[i]);
printf("%d\n",ans);
return 0;
}
F.部落划分
如果我们已经确定了最优划分时，最近的两个部落的距离为d，那么我们至多可以将野人划分为几个部落呢?
我们可以推出，如果两个野人之间的距离<d，那么它们必然是一个部落的。
那么我们可以\(O(n^2)\)枚举两个野人，将相同部落的野人的用并查集合并，最后可以得到野人至多被划分为几个部落。
现在的问题是，我们还无法知道答案d应该为多少。
幸运的是，令划分后的部落数\(y=f(d)\)，这个函数是单调递减的。
于是我们可以二分d，来找到最大的d，使得\(f(d)=K\)。此时即为答案。
时间复杂度\(O(n^2log(maxdis))\)。
# include <bits/stdc++.h>
using namespace std;
const int N=100005;
int a[N][2], f[N], n, k, F[N];
int find(int x){return F[x]==0?x:F[x]=find(F[x]);}
bool check(double x){
int res=n, u, v;
x=x*x;
memset(F,0,sizeof(F));
for (int i=1; i<=n; ++i) for (int j=i+1; j<=n; ++j) {
if ((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])>=x) continue;
u=find(i), v=find(j);
if (u!=v) F[u]=v, --res;
}
return res>=k;
}
int main ()
{
scanf("%d%d",&n,&k);
for (int i=1; i<=n; ++i) scanf("%d%d",&a[i][0],&a[i][1]);
double l=0, r=20000, mid;
for (int i=1; i<=50; ++i) {
mid=(l+r)/2;
if (check(mid)) l=mid;
else r=mid;
}
printf("%.2f\n",mid);
return 0;
}
G.2016
\((a\times b)\%2016=0\Rightarrow ((a\%2016)\times (b\%2016))\%2016=0\)
\(x=a\%2016,y=b\%2016\Rightarrow 0<=x<2016,0<=y<2016\)
预处理出满足条件的\((x,y)\)，对于每个这样的\((x,y)\)求出对应的\((a,b)\)有多少种即可。
显然应为\(\frac{n-x}{2016}\times \frac{m-y}{2016}\)。另外注意对x=0和y=0情况的特殊处理即可。
时间复杂度\(O(2016\times 2016)\)。
# include <bits/stdc++.h>
using namespace std;
const int N=2015;
struct Node{int x, y;}node[N*N];
int pos;
void init(){
for (int i=0; i<=2015; ++i) for (int j=0; j<=2015; ++j) {
if (i*j%2016) continue;
node[++pos].x=i; node[pos].y=j;
}
}
int main ()
{
init();
int n, m;
long long ans;
while (~scanf("%d%d",&n,&m)) {
ans=0;
for (int i=1; i<=pos; ++i) {
if (node[i].x>n || node[i].y>m) continue;
ans+=(long long)((n-node[i].x)/2016+(node[i].x?1:0))*((m-node[i].y)/2016+(node[i].y?1:0));
}
printf("%lld\n",ans);
}
return 0;
}