Educational Codeforces Round 62 做题记录

A.

题解：

发现就是找前缀 max = i 的点的个数，暴力扫一遍

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;
#define maxn 10005
int n;
int a[maxn];
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
    }
    int ans=0,last=0;
    for(int i=1;i<=n;++i)
    {
        last=max(a[i],last);
        if(i>=last)ans++;
    }
    printf("%d\n",ans);
    return 0;
}

 

B.

题解：

找到最左边的>，删去其左边的<；

或找到最右边的<，删去其右边的>;

两种方法取最优

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;
#define maxn 105
int T,n;
char s[maxn];
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        scanf("%s",s+1);
        int ans=n-1;
        for(int i=1;i<=n;++i)if(s[i]=='>')ans=min(ans,i-1);
        for(int i=n;i>=1;--i)if(s[i]=='<')ans=min(ans,n-i);
        printf("%d\n",ans);
    }
    return 0;
}

 

C.

题解：

我们将元素按b排序，从大往小加入

显然当前b为最小，已经固定

考虑找前k大的t，用优先队列维护就行

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;
#define maxn 300005
int n,k;
struct data
{
    ll t,b;
}a[maxn];
bool operator < (data A,data B)
{
    return A.b>B.b;
}
priority_queue<ll,vector<ll>,greater<ll>> pq;
int main()
{
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;++i)scanf("%I64d%I64d",&a[i].t,&a[i].b);
    sort(a+1,a+n+1);
    int sz=0;
    ll sum=0,ans=0;
    for(int i=1;i<=n;++i)
    {
        if(sz<k)
        {
            sz++;
            pq.push(a[i].t);sum+=a[i].t;
            ans=max(ans,sum*a[i].b);
        }
        else
        {
            sum+=a[i].t; pq.push(a[i].t);
            ll x=pq.top();pq.pop();
            sum-=x;
            ans=max(ans,sum*a[i].b);
        }
    }
    printf("%I64d\n",ans);
    return 0;
}

 

D.

题解：

观察发现，ans=2*3+3*4+4*5+……+(n-1)*n

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;
int n;
int main()
{
    scanf("%d",&n);
    ll ans=0;
    for(int i=2;i<n;++i)
    {
        ans+=1ll*i*(i+1);
    }
    printf("%I64d\n",ans);
    return 0;
}

 

E.

题解：

考虑题目给定的条件，不能出现奇数回文串等价于不能出现a[i]==a[i-2]的情况

按奇偶分类，取分类完的序列A，长度为len

等价于每个-1可以染k种颜色，不能出现相邻两个格子染色相同

如果A中没有已经确定的数，那么ans=k*(k-1)^(len-1)

如果A中有一个已经确定的数，那么ans=(k-1)^(len-1)

如果A中>=2个已确定的数，那么左右两端同上述情况，中间的就是一个经典的染色DP

f ( i , 0 )表示两端数字不同时，i和结尾不同的方案数

f ( i , 1 )表示两端数字不同时，i和结尾相同的方案数

g ( i , 0 )表示两端数字相同时，i和结尾不同的方案数

g ( i , 1 )表示两端数字相同时，i和结尾相同的方案数

 转移显然

细节和边界条件比较多，比赛时候写错一个小地方WA到死qwq

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
using namespace std;
#define maxn 200005
const ll mod = 998244353;
ll f[maxn][2],g[maxn][2];
ll fastpow(ll a,ll p)
{
    ll ans=1;
    while(p)
    {
        if(p&1)ans=ans*a%mod;
        a=a*a%mod;p>>=1; 
    }
    return ans;
}
ll work(ll *a,int n,ll k)
{
    for(int i=2;i<=n;++i)if(a[i]==a[i-1]&&a[i]!=-1)return 0;
    int p=0;
    for(int i=1;i<=n;++i)if(a[i]!=-1)p++;
    if(!p)
    {
        return fastpow(k-1,n-1)*k%mod;
    }
    else if(p==1)
    {
        return fastpow(k-1,n-1);
    }
    else
    {
        if(p==n)return 1;
        if(k==1)return 0;
        ll res=1;
        int l,r;
        for(int i=1;i<=n;++i)
        {
            if(a[i]!=-1)
            {
                l=i+1;
                break;
            }
            res=res*(k-1)%mod;
        }
        for(int i=n;i;--i)
        {
            if(a[i]!=-1)
            {
                r=i-1;
                break;
            }
            res=res*(k-1)%mod;
        }
        ll t=0;
        ll last=a[l-1];
        for(int i=l;i<=r+1;++i)
        {
            if(a[i]!=-1)
            {
                if(!t)
                {
                    last=a[i];
                    continue;
                }
                if(a[i]!=last)res=(res*f[t][0])%mod;
                else res=(res*g[t][0])%mod;
                t=0;last=a[i];
            }
            else t++;
        }
        return res;
    }
}
int n,cnt1,cnt2;
ll k;
ll a[maxn],b[maxn],c[maxn];
int main()
{
    scanf("%d%I64d",&n,&k);
    for(int i=1;i<=n;++i)
    {
        scanf("%I64d",&a[i]);
    }
    f[1][0]=k-2;f[1][1]=1;
    g[1][0]=k-1;g[1][1]=0;
    for(int i=2;i<=n;++i)
    {
        f[i][0]=(f[i-1][0]*(k-2)%mod+f[i-1][1]*(k-1)%mod)%mod;
        f[i][1]=f[i-1][0];
        g[i][0]=(g[i-1][0]*(k-2)%mod+g[i-1][1]*(k-1)%mod)%mod;
        g[i][1]=g[i-1][0];
    }
    for(int i=1;i<=n;i+=2)b[++cnt1]=a[i];
    for(int i=2;i<=n;i+=2)c[++cnt2]=a[i];
    ll ans=work(b,cnt1,k);
    ans=ans*work(c,cnt2,k)%mod;
    printf("%I64d\n",ans);
    return 0;
}

 

F.

题解：

考虑把横坐标看成点，纵坐标看成点，每次加入一对数相当于连边

然后R的大小就是连通块中横点个数*纵点个数

动态图连通性

离线下来分治线段树，用可撤销并查集维护

#include<bits/stdc++.h>
#define ll long long
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
#define maxn 600005
using namespace std;
int q,n=300000;
struct Edg
{
    int x,y;
}a[maxn],b[maxn];
int c[maxn],last[maxn];
struct Option
{
    int l,r,x,y;
}opt[maxn];
bool operator < (Edg A,Edg B)
{
    if(A.x==B.x)return A.y<B.y;
    return A.x<B.x;
}
bool operator == (Edg A,Edg B)
{
    return (A.x==B.x&&A.y==B.y);
}
int fa[maxn],sz1[maxn],sz2[maxn],size[maxn];
int find(int x)
{
    while(fa[x]!=x)x=fa[x];
    return x;
}
vector<pii> ve[maxn<<2];
void add(int rt,int l,int r,int ql,int qr,pii x)
{
    if(ql<=l&&r<=qr)
    {
        ve[rt].push_back(x);
        return;
    }
    int mid=(l+r)>>1;
    if(ql<=mid)add(rt<<1,l,mid,ql,qr,x);
    if(qr>mid)add(rt<<1|1,mid+1,r,ql,qr,x);
}
int s1[maxn],s2[maxn],top;
ll Ans[maxn],res=0;
void dfs(int rt,int l,int r)
{
    if(l>r)return;
    int bot=top;
    for(int i=0;i<ve[rt].size();++i)
    {
        int u=ve[rt][i].first,v=ve[rt][i].second;
        if(find(u)==find(v))continue;
        u=find(u),v=find(v);
        if(size[u]<size[v])swap(u,v);
        res-=1ll*sz1[u]*sz2[u]+1ll*sz1[v]*sz2[v];
        fa[v]=u;
        size[u]+=size[v];sz1[u]+=sz1[v],sz2[u]+=sz2[v];
        s1[++top]=v;s2[top]=u;
        res+=1ll*sz1[u]*sz2[u];
    }
    if(l==r)
    {
        Ans[l]=res;
    }
    int mid=(l+r)>>1;
    if(l!=r)
    {
        dfs(rt<<1,l,mid);
        dfs(rt<<1|1,mid+1,r);
    }
    while(top>bot)
    {
        int u=s1[top],v=s2[top];
        res-=1ll*sz1[v]*sz2[v];
        fa[u]=u;
        size[v]-=size[u];sz1[v]-=sz1[u];sz2[v]-=sz2[u];
        res+=1ll*sz1[u]*sz2[u]+1ll*sz1[v]*sz2[v];
        top--;
    }
}
int main()
{
    scanf("%d",&q);
    for(int i=1;i<=q;++i)
    {
        scanf("%d%d",&a[i].x,&a[i].y);
        a[i].y+=n;
        b[i]=a[i];
    }
    sort(a+1,a+q+1);
    int d=unique(a+1,a+q+1)-a-1;
    for(int i=1;i<=q;++i)c[i]=lower_bound(a+1,a+d+1,b[i])-a;
    int cnt=0;
    for(int i=1;i<=q;++i)
    {
        if(!last[c[i]])last[c[i]]=i;
        else
        {
            ++cnt;
            opt[cnt].l=last[c[i]],opt[cnt].r=i-1,opt[cnt].x=a[c[i]].x,opt[cnt].y=a[c[i]].y;
            last[c[i]]=0;
        }
    }
    for(int i=1;i<=d;++i)if(last[i])
    {
        ++cnt;
        opt[cnt].l=last[i],opt[cnt].r=q,opt[cnt].x=a[i].x,opt[cnt].y=a[i].y;
        last[i]=0;
    }
    for(int i=1;i<=cnt;++i)add(1,1,q,opt[i].l,opt[i].r,mp(opt[i].x,opt[i].y));
    for(int i=1;i<=n;++i)fa[i]=i,sz1[i]=1,size[i]=1;
    for(int i=1;i<=n;++i)fa[i+n]=i+n,sz2[i+n]=1,size[i+n]=1;
    dfs(1,1,q);
    for(int i=1;i<=q;++i)printf("%I64d ",Ans[i]);
    return 0;
}

 

G.

题解：

类似于ZJOI的某道题，多次询问两点最短路

一样的思路，分治最短路

分治改成树分治就好了

（这F和G怎么都是胖题）

#include<bits/stdc++.h>
#define ll long long
#define maxn 600005
using namespace std;
int n,q;
vector<int> T[maxn];
int root;
namespace Tree
{
    struct edge
    {
        int to,next;
    }e[maxn<<1];
    int head[maxn],p;
    int cnt;
    void addedge(int u,int v)
    {
        e[++p].to=v;e[p].next=head[u];head[u]=p;
        e[++p].to=u;e[p].next=head[v];head[v]=p;
    }
    int rt,nowsize;
    bool del[maxn];
    int sum[maxn],f[maxn];
    void getroot(int u,int fa)
    {
        sum[u]=1;f[u]=0;
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(v==fa||del[v])continue;
            getroot(v,u);
            sum[u]+=sum[v];
            if(sum[v]>f[u])f[u]=sum[v];
        }
        f[u]=max(f[u],nowsize-sum[u]);
        if(f[u]<f[rt])rt=u;
    }
    void solve(int u)
    {
        del[u]=1;
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(del[v])continue;
            rt=0;
            f[rt]=nowsize=sum[v];
            getroot(v,0);
            T[u].push_back(rt);
            T[u+1].push_back(rt+1); 
            solve(rt);
        }
    }
    void work()
    {
        rt=0;
        f[rt]=nowsize=n;
        getroot(1,0);
        root=rt;
        solve(rt);
    }
};
namespace Graph
{
    const ll inf = (ll)2e18;
    struct Query
    {
        int u,v,id;
        Query(){}
        Query(int U,int V,int ID){u=U;v=V;id=ID;}
    };
    ll Ans[maxn];
    vector<Query> vq[maxn];
    struct edge
    {
        int to,next;
        ll w;
    }e[maxn<<2];
    bool used[maxn];
    bool del[maxn];
    int head[maxn],p;
    void addedge(int u,int v,ll w)
    {
        e[++p].to=v;e[p].w=w;e[p].next=head[u];head[u]=p;
        e[++p].to=u;e[p].w=w;e[p].next=head[v];head[v]=p;
    }
    struct node
    {
        int x;ll dis;
        node(){}
        node(int id,ll d){x=id;dis=d;}
    };
    bool operator < (node a,node b)
    {
        return a.dis>b.dis;
    }
    ll dis[maxn];
    void dijkstra(int s)
    {
        priority_queue<node> q;
        q.push(node(s,0));dis[s]=0;
        while(!q.empty())
        {
            int u=q.top().x;q.pop();
            if(used[u])continue;
            used[u]=1;
            for(int i=head[u];i;i=e[i].next)if(!del[e[i].to])
            {
                int v=e[i].to;
                ll w=e[i].w;
                if(dis[v]>dis[u]+w)
                {
                    dis[v]=dis[u]+w;
                    q.push(node(v,dis[v]));
                }
            }
        }
    }
    int belong[maxn];
    void clear(int u)
    {
        dis[u]=inf;used[u]=0;
        for(int i=0;i<T[u].size();++i)clear(T[u][i]);
    }
    void get_belong(int u,int rt,int tp)
    {
        belong[u]=rt+tp;
        for(int i=0;i<T[u].size();++i)
        {
            int v=T[u][i];
            get_belong(v,rt,tp);
        }
    }
    void dfs(int rt)
    {
        if(!vq[rt].size())return;
        clear(rt);
        clear(rt+1);
        dijkstra(rt);
        for(int i=0;i<vq[rt].size();++i)
        {
            int u=vq[rt][i].u,v=vq[rt][i].v;
            Ans[vq[rt][i].id]=min(Ans[vq[rt][i].id],dis[u]+dis[v]);
        }
        clear(rt);
        clear(rt+1);
        dijkstra(rt+1);
        for(int i=0;i<vq[rt].size();++i)
        {
            int u=vq[rt][i].u,v=vq[rt][i].v;
            Ans[vq[rt][i].id]=min(Ans[vq[rt][i].id],dis[u]+dis[v]);
        }
        del[rt]=1;del[rt+1]=1;
        for(int i=0;i<T[rt].size();++i)get_belong(T[rt][i],T[rt][i],0);
        for(int i=0;i<T[rt+1].size();++i)get_belong(T[rt+1][i],T[rt+1][i],-1);
        for(int i=0;i<vq[rt].size();++i)
        {
            int u=vq[rt][i].u,v=vq[rt][i].v;
            if(u==rt||v==rt||u==rt+1||v==rt+1)continue;
            if(belong[u]==belong[v])vq[belong[u]].push_back(vq[rt][i]);
        }
        for(int i=0;i<T[rt].size();++i)dfs(T[rt][i]);
    }
    void work()
    {
        Tree::work();
        for(int i=1;i<=q;++i)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            vq[root].push_back(Query(u,v,i));
            Ans[i]=inf;
        }
        dfs(root);
        for(int i=1;i<=q;++i)printf("%I64d\n",Ans[i]);
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        ll w;
        scanf("%I64d",&w);
        Graph::addedge(i*2-1,i*2,w);
    }
    for(int i=1;i<n;++i)
    {
        int x,y;ll w1,w2;
        scanf("%d%d%I64d%I64d",&x,&y,&w1,&w2);
        Graph::addedge(x*2-1,y*2-1,w1);
        Graph::addedge(x*2,y*2,w2);
        Tree::addedge(x*2-1,y*2-1);
    }
    scanf("%d",&q); 
    Graph::work();
    return 0;
}