2018-2019 ACM-ICPC, Asia Nanjing Regional Contest 一些题解

比较顺利的一场……
A Adrien and Austin
博弈水题，规律是N是偶数（包括0）K等于1的时候后手必胜，剩下的情况都是先手胜
J Prime Game
题意概括一下就是求所有区间里的数字的不同素因子的个数的和。
应该是花式算贡献的题，我们记录一下每个素因子出现的最后位置last[k],那么对于ai，如果他存在素因子一个k，那么他首先向后贡献了n - i +1,但是和离他最近的last[k]位置是有重复的，最后的贡献就是(n-i+1)*(i-last[i])

#include 
#include
#define ll long long
using namespace std;
const int MAXN = 1e6 + 6;
int prime[MAXN+10];
bool isprime[MAXN];
void getPrime()
{
    memset(prime,0,sizeof(prime));
    memset(isprime,0,sizeof(isprime));
    for(int i = 2;i<=MAXN;i++)
    {
        if(!prime[i])isprime[i] = 1, prime[++prime[0]] = i;
        for(int j = 1;j<=prime[0] && prime[j] <= MAXN/i;j++)
        {
            prime[prime[j]*i] = 1;
            if(i % prime[j] == 0) break;
        }
    }
}
ll a[MAXN];
int sz[MAXN];
ll fac[100][2];
int cnt = 0;
int getFac(ll x)
{
    cnt = 0;
    ll tmp = x;
    for(int i = 1;prime[i] <= tmp/prime[i];i++)
    {
        fac[cnt][1] = 0;
        if(tmp%prime[i] == 0)
        {
            fac[cnt][0] = prime[i];
            while(tmp % prime[i] == 0)
            {
                fac[cnt][1]++;
                tmp /= prime[i];
            }
            cnt++;
            if(isprime[tmp]) break;
        }
    }
    if(tmp != 1)
    {
        fac[cnt][0] = tmp;
        fac[cnt++][1] =1;
    }
    return cnt;
}
map<ll,int> m;
int main()
{
    //freopen("input.txt","r",stdin);
    getPrime();
    //cout<
    int n;
    scanf("%d",&n);
    ll ans = 0;
    for(int i = 1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        getFac(a[i]);
        for(int j = 0;j<cnt;j++){
            ans+=(n-i+1)*(1LL*i-m[fac[j][0]]);
            m[fac[j][0]] = i;
            //cout<
        }
    }
    printf("%lld\n",ans);
    return 0;
}

I - Magic Potion
网络流简单二分图模型建模，多了两个限制。
第一个限制，左边的点最多只能流出2
第二个限制，附加的只有k的流量
第一个限制让我们不得不让流进左边的点的流量限制在2，第二个限制我们就不能让所有的附加边连接到超级源点了，需要限流。
我们附加一个源点，超级源点向这个点连接一个流量k的点，这个源点再向左边的点连接容量为1的点。表示只能使用K个，每个人只能使用一次。剩下的就很简单了。

#include 
#include
#define ll long long
using namespace std;
const int MAXN = 3010;
const int MAXM = 1200001;
const int INF = 0x3f3f3f3f;
struct Edge
{
    int to,next,cap,flow,from;
}edge[MAXM];
int tot,head[MAXN];
void init()
{
    memset(head,-1,sizeof(head));
    tot = 2;
}
void addedge(int u,int v,int w,int rw = 0)
{
    edge[tot].to = v,edge[tot].from = u,edge[tot].cap = w,edge[tot].flow = 0;
    edge[tot].next = head[u];head[u] = tot++;
    edge[tot].to = u,edge[tot].from = v,edge[tot].cap = rw,edge[tot].flow = 0;
    edge[tot].next = head[v];head[v] = tot++;
}
int Q[MAXN];
int dep[MAXN],cur[MAXN],sta[MAXN];
bool bfs(int s,int t,int n)
{
    int front = 0,tail = 0;
    memset(dep,-1,sizeof(dep));
    dep[s] = 0;
    Q[tail++] = s;
    while(front < tail)
    {
        int u  =Q[front++];
        for(int i = head[u];i != -1;i=edge[i].next)
        {
            int v = edge[i].to;
            if(edge[i].cap > edge[i].flow && dep[v] == -1)
            {
                dep[v]= dep[u] + 1;
                if(v == t) return 1;
                Q[tail++] = v;
            }
        }
    }
    return 0;
}
int dinic(int s,int t,int n)
{
    int maxflow = 0;
    while(bfs(s,t,n))
    {
        for(int i = 0;i<n;i++) cur[i] = head[i];
        int u = s,tail = 0;
        while(cur[s] != -1)
        {
            if(u == t)
            {
                int tp = INF;
                for(int i = tail-1;i >= 0;i--)
                {
                    tp = min(tp,edge[sta[i]].cap -edge[sta[i]].flow);
                }
                maxflow += tp;
                for(int i = tail-1;i >= 0;i--)
                {
                    edge[sta[i]].flow += tp;
                    edge[sta[i]^1].flow -= tp;
                    if(edge[sta[i]].cap -edge[sta[i]].flow == 0) tail = i;
                }
                u = edge[sta[tail]^1].to;
            }
            else if(cur[u] != -1 && edge[cur[u]].cap > edge[cur[u]].flow && dep[u]+1 == dep[edge[cur[u]].to])
            {
                sta[tail++] = cur[u];
                u = edge[cur[u]].to;
            }
            else
            {
                while(u != s && cur[u] == -1)
                {
                    u = edge[sta[--tail]^1].to;
                }
                cur[u] = edge[cur[u]].next;
            }
        }
    }
    return maxflow;
}
void debug()
{
    for(int i = 0;i<tot;i += 2)
    {
        printf("%d->%d : cap = %d flow = %d\n",edge[i].from,edge[i].to,edge[i].cap,edge[i].flow);
    }
}
int main()
{

    int n,m,k;
    cin>>n>>m>>k;
    init();
    int s = 0,s1 = (n + m)+1,t = (n +m)+2;
    addedge(s,s1,k);
    for(int i = 1;i<=n;i++)
    {
        addedge(s,i,1);
        addedge(s1,i,1);
        int t;
        cin>>t;
        for(int j = 0;j<t;j++)
        {
            int x;
            cin>>x;
            addedge(i,x+n,1);
        }
    }
    for(int i = 1;i<=m;i++) addedge(i+n,t,1);
    int ans = dinic(s,t,(n+m)+4);
    //debug();
    cout<<ans<<endl;
    return 0;
}

G Pyramid
无敌的队友怒推规律，发现是$\left(\genfrac{}{}{0ex}{}{n}{4}\right)$,剩下的就是输出了。
D Country Meow
裸最小球覆盖……怒抄模板就过了