[Atcoder Regular Contest 061] Tutorial

Link:

ARC061 传送门

C:

暴力$dfs$就好了

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
ll n,res=;
int dgt[],cnt;

void dfs(int dep,ll sum)
{
    if(dep==cnt){res+=sum;return;}
    for(int i=dep+;i<=cnt;i++)
    {
        ll t=;
        for(int j=dep+;j<=i;j++)
            t=t*+dgt[j];
        dfs(i,sum+t);
    }
}

int main()
{
    scanf("%lld",&n);
    for(;n;n/=) dgt[++cnt]=n%;
    reverse(dgt+,dgt+cnt+);dfs(,);
    printf("%lld",res);
    return ;
}

Problem C

D:

没有办法直接上暴力，但可以采取计算贡献的方式：

每个有色点都对周围的9个正方形恰好有1点贡献

将$9*k$个正方形用其左上角的坐标表示，排序后将相同的合并就是该正方形的个数了

最后用总的减去个数为$[1,9]$的就是个数为0的个数了

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=1e5+;
P sqr[MAXN*];
ll sum=,cnt[];
int n,m,k,x,y,tot;
int dx[]={-,-,-,-,-,-,,,};
int dy[]={-,-,,-,-,,-,-,};

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=;i<=k;i++)
    {
        scanf("%d%d",&x,&y);
        for(int j=;j<;j++)
        {
            int fx=x+dx[j],fy=y+dy[j];
            if(fx>&&fy>&&fx<=n-&&fy<=m-)
                sqr[++tot]=P(fx,fy);
        }
    }

    sort(sqr+,sqr+tot+);
    int cur=;
    for(int i=;i<=tot;i++)
        if(sqr[i]==sqr[i-]) cur++;
        else cnt[cur]++,cur=;
    if(k) cnt[cur]++;//不要忘记对末尾的处理 

    for(int i=;i<=;i++) sum+=cnt[i];
    cnt[]=1ll*(m-)*(n-)-sum;
    for(int i=;i<;i++) printf("%lld\n",cnt[i]);
    return ;
}

Problem D

E:

先来说说正解：拆点最短路

在每个站点中，对于每一个其能转换到的公司都新设立一个站点，并建立一个总站

也就是说，对于边$(u,v,c)$，建边$(u,u[c],1),(v,v[c],1),(u[c],v[c],0)$

这样体现了是否转换公司的抉择，直接在新图上求最短路就好了

但注意最后答案要除以2，毕竟这样建图每转换一次其实计算了2次1

我的做法又是极为感性的

在每个点都用一个$set$维护当前能达到最短距离时的末尾公司名，转移时贪心

感觉没什么问题，但不知道为什么在距离相同时一定要先处理编号较大的节点？请各位神犇们指点啊……

#include <bits/stdc++.h>

using namespace std;
#define X first
#define Y second
typedef pair<int,int> P;
const int MAXN=1e5+,INF=<<;
int n,m,x,y,z,dist[MAXN];
set<int> s[MAXN];
vector<P> G[MAXN];
//必须要用set，因为可能dist最小时有多种公司供选择
struct cmp
{//一定要编号大的先处理（原因未知）
    bool operator() (const P& a,const P& b)
    {return a.X!=b.X?a.X>b.X:a.Y<b.Y;}
};

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        G[x].push_back(P(y,z));G[y].push_back(P(x,z));
    }

    priority_queue<P,vector<P>,cmp > q;
    for(int i=;i<MAXN;i++) dist[i]=INF;
    dist[]=;q.push(P(,));
    while(!q.empty())
    {
        P t=q.top();q.pop();
        int u=t.Y,cost=t.X,tmp;
        if(cost>dist[u]) continue;
        for(int i=;i<G[u].size();i++)
        {
            int v=G[u][i].X,col=G[u][i].Y;
            tmp=dist[u]+(!s[u].count(col));
            if(tmp==dist[v]) s[v].insert(col);
            else if(tmp<dist[v])
            {
                s[v].clear();s[v].insert(col);
                dist[v]=tmp,q.push(P(dist[v],v));
            }
        }
    }
    printf("%d",(dist[n]==INF)?-:dist[n]);
    return ;
}

Problem E

F:

设游戏结束前使用了$x$张$b$，$y$张$c$

可以发现最终一共使用了$n+x+y$张卡片，且由于最后一张一定是$a$可以不用考虑

因此可以比较容易的写出一下的式子：

$res=\sum_{p=0}^{m+k} C_{n−1+x+y}^{n-1}*3^{m+k−x−y}*\sum_{0\le x\le m,0\le y\le k}[x+y=p]C_{p}^{x}$

为了将计算的时间降到$O(n)$，我们可以用递推的方式优化$\sum C_{p}^{x}$

设$f(i)$表示$p=i$时该式的值，发现递推有三个阶段（假设$m<k$）：

1、$i<m$时$f(i)=\sum_{j=0}^{i} C_i^j$

2、$m\le i<k$时$f(i)=\sum_{j=0}^{m} C_i^j$

3、$k\le i$时$f(i)=\sum_{j=i-k}^m C_i^j$

将这些式子放到杨辉三角形上可以发现：

1阶段时$f(i)=f(i-1)*2$（二项式系数和的基本结论）

2阶段时$f(i)=f(i-1)*2-C_{i-1}^m$（减掉右边界的值）

3阶段时$f(i)=f(i-1)*2-C_{i-1}^m-C_{i-1}^{i-1-k}$（减掉左右边界的值）

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int MAXN=(3e5+)*,MOD=1e9+;
ll res=,cur=;
int n,m,k,fac[MAXN],inv[MAXN];

ll quick_pow(ll a,ll b)
{
    ll ret=;
    for(;b;b>>=,a=a*a%MOD)
        if(b&) ret=ret*a%MOD;
    return ret;
}
int C(int a,int b)
{if(a<b||b<) return ;return 1ll*fac[a]*inv[b]%MOD*inv[a-b]%MOD;}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    fac[]=;
    for(int i=;i<MAXN;i++)
        fac[i]=1ll*fac[i-]*i%MOD;
    inv[MAXN-]=quick_pow(fac[MAXN-],MOD-);
    for(int i=MAXN-;i>=;i--)
        inv[i]=1ll*inv[i+]*(i+)%MOD;

    for(int i=n;i<=n+m+k;i++)
        (res+=C(i-,n-)*cur%MOD*quick_pow(,n+m+k-i)%MOD)%=MOD,
        cur=(*cur-C(i-n,m)+MOD-C(i-n,i-n-k)+MOD)%MOD;
    printf("%lld",res);
    return ;
}

Problem F

优化方式涨姿势了