AIsing Programming Contest 2020

最新推荐文章于 2020-07-16 11:55:30 发布

Huah_2018

最新推荐文章于 2020-07-16 11:55:30 发布

阅读量313

点赞数 1

文章标签： atcoder AIsing 2020

本文链接：https://blog.csdn.net/huah_2018/article/details/107294983

版权

D - Anything Goes to Zero
设串 $X$ 中 $1$ 的个数为 $s u m$ ，若翻转的是 $1$ ， $1$ 的个数减 $1$ ，若翻转的是 $0$ ， $1$ 的个数加 $1$ ，故我们得到两个模数 $s u m - 1$ 和 $s u m + 1$ ，故两个模数分开处理翻转 $0$ 和 $1$ 的情况。
计算 $f(X_i)$ ，第一次取模 $s u m - 1$ 或 $s u m + 1$ 会使得 $x_i<=2e5$ ，可以对前 $2 e 5$ 打表，也可以直接计算，因为计算 $f(X_i)$ 的时间复杂度显然为 $O(logX_i)$ 。

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int N=2e5+5;
ll p[N];
int pre[N],bk[N],ans[N];
int n;
char s[N];
int get(int x)
{
    int ans=0;
    while(x)
        x=x%__builtin_popcount(x),ans++;
    return ans;
}
void solve(int x,int sum)
{
    if(sum<=0) return;
    p[0]=1;for(int i=1;i<N;i++) p[i]=p[i-1]*2%sum;
    for(int i=1;i<=n;i++)
        pre[i]=(pre[i-1]+(s[i]=='1')*p[i-1])%sum;
    for(int i=n;i>=1;i--)
        bk[i]=(bk[i+1]+(s[i]=='1')*p[i-1])%sum;
    for(int i=1;i<=n;i++)
        if(x==1&&s[i]=='1')
    {
        int res=(pre[i-1]+bk[i+1])%sum;
        ans[i]=1+get(res);
    }
    else if(x==0&&s[i]=='0')
    {
        int res=(pre[i-1]+bk[i+1]+p[i-1])%sum;
        ans[i]=1+get(res);
    }
}
int main()
{
    scanf("%d%s",&n,s+1);
    reverse(s+1,s+1+n);
    int sum=0;
    for(int i=1;i<=n;i++) sum+=s[i]=='1';
    solve(1,sum-1);
    solve(0,sum+1);
    reverse(ans+1,ans+1+n);
    for(int i=1;i<=n;i++) printf("%d\n",ans[i]);
}

E - Camel Train
若 $l = r$ ，无需考虑它的位置，直接加入总答案。
若 $l > r$ ，把它分为第一类。
若 $l > r$ ，令其 $k = n - k$ ，交换他们的 $l, r$ ，并分其为第二类。
设计 $s_{0,i}$ 为第一类放前 $i$ 个位置的最大收益（即第一类中，对于某个下标 $j$ ，如果 $j$ 放在前 $i$ 个位置则其收益为 $l_j$ ，否则为 $r_j$ ）。
设计 $s_{1,i}$ 为第二类放后 $i$ 个位置的最大收益。
那么第一类和第二类的最大收益为
$max(sum_{0,i}+sum_{1,n-i})(i=[0,1,2,...,n-1,n])$ 。
考虑如何计算 $s_{0,i}$ ，对于 $s_{1,i}$ 为相同的情况。
考虑其顺序，比较两只不同的骆驼 $i, j$ ，要使得 $l_i+r_j>l_j+r_i$ ，即
$l_i-r_i>l_j-r_j$ ，对于 $l_i-r_i=l_j-r_j$ 的，我们让 $k$ 较大的排在前面。
然后，枚举位置的个数 $i$ ，每次增加一个位置贪心的加入收益最大的。
如何判断一只骆驼 $k_j,l_j,r_j$ 可以加入前 $i$ 个位置？
设计 $f_1,f_2,...,f_n$ ， $f_u$ 分别表示前 $u$ 个位置剩余的可用位置的数量。
每次加入一个骆驼时 $j$ 时，我们贪心它加入第 $k_j$ 个位置（因为只要 $j$ 前面有空位，我们可以自由地把它移动到空位里），那么更新 $f_{k_j,k_j+1,...,n}=f_{k_j,k_j+1,...,n}-1$ 。
如果某个时刻对于某个 $u$ 有 $f_u=0$ ，即 $u$ 前面的位置已经被占满了，那么对于 $k_j<=u$ 的 $j$ 骆驼不可以加入前 $u$ 个位置。
于是可以用线段树维护区间的最小值的最大端点，至此问题可以在 $O (n l o g n)$ 时间内解决。

比赛时候太困了，以至于线段树都能写错，在此留图做个纪念。
在这里插入图片描述

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int N=2e5+5;
struct node
{
    int k,l,r;
    node(int k=0,int l=0,int r=0):k(k),l(l),r(r){}
};
struct haha
{
    int id,v,k;
    haha(int id=0,int v=0,int k=0):id(id),v(v),k(k){}
    bool operator<(const haha&o)const
    {
        if(v==o.v) return k<o.k;
        return v<o.v;
    }
};
vector<node>vl,vr;
int n,t[N<<2],lz[N<<2],ss[N];
ll ans=0;
ll s[2][N];
void update(int l,int r,int k)
{
    assert(t[k]>=0);
    if(l!=r)
    {
        t[k<<1]-=lz[k];t[k<<1|1]-=lz[k];
        lz[k<<1]+=lz[k];lz[k<<1|1]+=lz[k];
        t[k]=min(t[k<<1],t[k<<1|1]);
    }
    lz[k]=0;
}
int query(int l,int r,int k)
{
    if(lz[k]) update(l,r,k);
    if(t[k]>0) return 0;
    if(l==r) return l;
    int m=l+r>>1;
    if(t[k<<1|1]<=0) return query(m+1,r,k<<1|1);
    return query(l,m,k<<1);
}
void fix(int l,int r,int k,int x,int y)
{
    if(lz[k]) update(l,r,k);
    if(r<x||l>y) return;
    if(l>=x&&r<=y)
    {
        lz[k]++;t[k]--;update(l,r,k);return;
    }
    int m=l+r>>1;
    fix(l,m,k<<1,x,y);fix(m+1,r,k<<1|1,x,y);
    t[k]=min(t[k<<1],t[k<<1|1]);
}
void build(int l,int r,int k)
{
    t[k]=l;lz[k]=0;
    if(l==r) return;
    int m=l+r>>1;
    build(l,m,k<<1);build(m+1,r,k<<1|1);
    t[k]=l;
}
void solve(vector<node>v,int p)
{
    build(1,n,1);
    priority_queue<haha>q;
    ll sum=0;
    for(int i=0;i<v.size();i++) sum+=v[i].r,q.push(haha(i,v[i].l-v[i].r,v[i].k));
    s[p][0]=sum;
    for(int i=1;i<=n;i++)
    {
        int pos=query(1,n,1);
        //cout<<pos<<' '<<t[1]<<endl;
        while(!q.empty())
        {
            int id=q.top().id;q.pop();
            if(v[id].k==0) continue;
            if(v[id].k>pos)
            {
                //cout<<v[id].l<<' '<<v[id].r<<' '<<v[id].k<<endl;
                sum=sum-v[id].r+v[id].l;
                fix(1,n,1,v[id].k,n);
                break;
            }
        }
        s[p][i]=max(sum,s[p][i-1]);
    }
}
fstream in,out;
void getts()
{
    int t=50;
    in.open("1.txt");
    in<<t<<endl;
    while(t--)
    {
        int n=5;
        in<<n<<endl;
        for(int i=1;i<=n;i++)
        {
            int k=rand()%n+1,l=rand()%100+1,r=rand()%100+1;
            in<<k<<' '<<l<<' '<<r<<endl;
        }
    }
    in.close();
}
bool de=false;
int main()
{
    srand(time(0));
    //getts();freopen("1.txt","r",stdin);out.open("out.txt");de=true;
    int t;scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        vl.clear();vr.clear();ans=0;
        for(int i=1;i<=n;i++)
        {
            int k,l,r;
            scanf("%d%d%d",&k,&l,&r);
            if(l==r) ans+=l;
            else if(l>r) vl.push_back({k,l,r});
            else vr.push_back({n-k,r,l});
        }
        for(int i=0;i<=n;i++) s[0][i]=s[1][i]=0;
        solve(vl,0);
        solve(vr,1);
        ll res=0;
        for(int i=0;i<=n;i++)
            res=max(res,s[0][i]+s[1][n-i]);
        if(!de) printf("%lld\n",ans+res);
        if(de) out<<ans+res<<endl;
    }
}

F Two Snuke
定义 $ds=s_2-s_1,dn=n_2-n_1,du=u_2-u_1,dk=k_2-k_1,de=e_2-e_1$ 。
再定义 $s=2*s_1,n=2*n_1,u=2*u_1,k=2*k_1,e=2*e_1$ 。
问题等价于找到对于满足以下条件的所有划分，求所有 $d s * d n * d u * d k * d e$ 之和：

$0 < = s, n, u, k, e$
$s, n, u, k, e 是偶数$
$1 < = d s, d n, d u, d k, d e$
$s + n + u + k + e + d s + d n + d u + d k + d e < = N$

划分的方案数等价于 $N$ 个球分为十一堆，扔掉最后一堆球，剩余的前 $5$ 堆球为 $s, n, u, k, e$ ，后 $5$ 堆球为 $d s, d n, d u, d k, d e$ 。

再考虑每种方案中的权值 $d s * d n * d u * d k * d e$ ，等价于再在后五堆球每堆各选一个球的方案数。

在每堆球中选择一个后，把该球删除，并把在这堆中编号小于被删除的球的编号和编号大于被删除的球的编号再分为两堆，这样，问题等价于：
求 $N - 5$ 个球排成一排，将其分为 $16$ 堆，使得前 $5$ 堆球的个数为偶数的方案数。

在此问题基础上设计 $D p$ ，再采用矩阵加速即可。

#include<bits/stdc++.h>
#define mems(x,y) memset(x,y,sizeof(x))
using namespace std;
typedef long long ll;
const int MS=30,mod=1e9+7;
struct Mat//矩阵
{
    ll a[MS][MS];
    int n,m;
    Mat(int n=0,int m=0):n(n),m(m) { mems(a,0);}
    Mat operator*(const Mat&B)const
    {
        Mat C(n,B.m);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=B.m;j++)
                for(int k=1;k<=m;k++)
                C.a[i][j]=(C.a[i][j]+a[i][k]*B.a[k][j])%mod;
        return C;
    }
};
Mat qpow(Mat a,int n)
{
    Mat ans(a.n,a.n);
    for(int i=1;i<=a.n;i++) ans.a[i][i]=1;
    while(n)
    {
        if(n&1) ans=ans*a;
        a=a*a;
        n>>=1;
    }
    return ans;
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        int n;scanf("%d",&n);
        n+=10;
        Mat A(21,21);
        for(int i=1;i<=5;i++) A.a[16+i][i]=1;
        for(int i=2;i<=5;i++) A.a[i-1][i]=1;
        for(int i=6;i<=16;i++) A.a[i-1][i]=A.a[i][i]=1;
        for(int i=17;i<=21;i++) A.a[i-16][i]=1;
        A=qpow(A,n);
        printf("%lld\n",A.a[1][16]);
    }
}

Huah_2018

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
AIsing Programming Contest 2020

D - Anything Goes to Zero设串XXX中111的个数为sumsumsum，若翻转的是111，111的个数减111，若翻转的是000，111的个数加111，故我们得到两个模数sum−1sum-1sum−1和sum+1sum+1sum+1，故两个模数分开处理翻转000和111的情况。计算f(Xi)f(X_i)f(Xi)，第一次取模sum−1sum-1sum−1或sum+1sum+1sum+1会使得xi<=2e5x_i<=2e5xi<=2e5，可以对前2e52e52
复制链接

扫一扫