HUAS 2017暑假第六周比赛-题解

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;
}