【Atcoder】AGC018 C-F简要题解

*C.Coins

只有金牌银牌可以贪心：
所有点按$A_i-B_i$降序排序，前$X$选金牌，后$Y$个选金牌。

那么三种牌的情况同样可以按$A_i-B_i$排序，显然金牌选得是前缀中的一些点，银牌选的是后缀中的一些点，也就是它们的选择区间不会相交。

考虑枚举$k$表示前$k$个中$X$个选金牌，后$n-k$中$Y$个选银牌，剩下的选铜牌。

注意划分后的前后部分又转成了只有两种牌的情况，$set$维护即可。

---

*D.Tree and Hamilton Path

转化一下，考虑最大化每条边被经过的次数。

边$(u,v)$被经过的次数上限为$2\min (s{z}_u,s{z}_v)$，所以尽量让$|s{z}_u-s{z}_v|$小一些。
那么可以找到重心：

• 若有两个重心，$s{z}_u=s{z}_v$，在$u,v$子树内交替跳点刚好可以跳完，也就是除了$(u,v)$边比上限少一，其它边都达到了上限
• 若只有一个重心，找到与重心连出的权值最小的一条边，除了这条边比上限少一，其它边都达到了上限

---

*E.Sightseeing Plan

设从原点出发向上/右走到$(x,y)$的方案数为$C(x,y)$

显然$C(x,y)=\left(\genfrac{}{}{0ex}{}{x+y}{x}\right)$，但组合数优化不下去，考虑递推表达：

$C(X+1,Y)=\sum _{y=0}^{Y}C(X,y)$

如下图，枚举$x=X$时$y$的值，接下来强制$x+=1$，到终点的路径是唯一的。

同理可以拓展到二维平面上：
$\sum _{x=0}^X\sum _{y=0}^{Y}C(x,y)=C(X+1,Y+1)-1$

将$C(X,Y+1)=\sum _{x=0}^{X}C(x,Y)$套入$C(X+1,Y)=\sum _{y=0}^{Y}C(X,y)$得到。
也可以用下图理解，到指定点$(x,y)$后，强制$y+=1$后移动到$(X,y)$再强制$x+=1$移动到$(X,Y)$，路径唯一。

发现$(0,0)\to (X+1,0)\to (X+1,Y+1)$这条路径并不会被算进去，所以是$C(X+1,Y+1)-1$。

推广得到：
$\sum _{x=X1}^{X2}\sum _{y=Y1}^{Y2}C(x,y)=C(X2+1,Y2+1)-C(X2+1,Y1)-C(X1,Y2+1)+C(X1,Y1)$

所以求解原点到达一个矩形内所有点的方案数直接用原点到矩形的四个端点方案数来计算。

考虑枚举经过第二个矩形时的进入点和离开点，若进入点和离开点之间欧几里得距离为$l$，则这组路径的方案会被算$l+1$次，考虑把欧几里得距离拆分成离开点坐标和贡献为正，进入点坐标和贡献为负。
因为要把每个点的贡献单独计算，所以每次枚举第一，三个矩形的四个端点之一，两两组合，总贡献就是系数相乘。

具体可以看代码

#include<bits/stdc++.h>
#define pb push_back
#define mid (l+r>>1)
#define lc k<<1
#define rc k<<1|1
using namespace std;
const int N=2e6+10,mod=1e9+7;
typedef long long ll;
typedef double db;

int x[7],y[7],frc[N],nv[N];
int ans,Ax,Ay,Bx,By;
vector<int>f[4],g[4];

inline void ad(int &x,int y){x+=y;if(x>=mod) x-=mod;}
inline void dc(int &x,int y){x-=y;if(x<0) x+=mod;}

inline int C(int n,int m)
{return (ll)frc[n+m]*nv[n]%mod*(ll)nv[m]%mod;}

inline int cal(int oa,int ob)
{
    int x,y,re=0,ix=f[oa][0],iy=f[oa][1],jx=g[ob][0],jy=g[ob][1];
    for(x=Ax;x<=Bx;++x)
    	ad(re,(ll)(x+By+1)*C(x-ix,By-iy)%mod*(ll)C(jx-x,jy-By-1)%mod),//(jy-By-1表示强制下一步离开y=By)
	    dc(re,(ll)(x+Ay)*C(jx-x,jy-Ay)%mod*(ll)C(x-ix,Ay-iy-1)%mod); //(Ay-iy-1)上同理 
	for(y=Ay;y<=By;++y)
	    ad(re,(ll)(Bx+y+1)*C(Bx-ix,y-iy)%mod*(ll)C(jx-Bx-1,jy-y)%mod),//(jx-Bx-1表示强制下一步离开x=Bx)
	    dc(re,(ll)(Ax+y)*C(jx-Ax,jy-y)%mod*(ll)C(Ax-ix-1,y-iy)%mod);//(Ax-ix-1)上同理 
	if(f[oa][2]==g[ob][2]) return re;
	return re?mod-re:0;
}

int main(){
	int i,j;frc[0]=frc[1]=nv[0]=nv[1]=1;
	for(i=2;i<N;++i)
	 frc[i]=(ll)frc[i-1]*i%mod,
	 nv[i]=(ll)(mod-mod/i)*nv[mod%i]%mod;
	for(i=2;i<N;++i) nv[i]=(ll)nv[i-1]*nv[i]%mod;
	
	for(i=1;i<7;++i) scanf("%d",&x[i]);
	for(i=1;i<7;++i) scanf("%d",&y[i]);
	
	f[0]={x[1]-1,y[1]-1,1};
	f[1]={x[1]-1,y[2],-1};
	f[2]={x[2],y[1]-1,-1};
	f[3]={x[2],y[2],1};
	
	g[0]={x[6]+1,y[6]+1,1};
	g[1]={x[6]+1,y[5],-1};
	g[2]={x[5],y[6]+1,-1};
	g[3]={x[5],y[5],1};
	
	Ax=x[3];Ay=y[3];Bx=x[4];By=y[4];
	
	for(i=0;i<4;++i)
	 for(j=0;j<4;++j)
	  ad(ans,cal(i,j));
	  
	printf("%d",ans);
	return 0;
}

---

*F.Two Trees

关键性质：$x_i$的奇偶性取决于它的儿子数的奇偶。

若点$i$在A树和B树中儿子数的奇偶性不同，则无解。

考虑只需要 x i = { − 1 , 0 , 1 } x_i=\{-1,0,1\} xi​={−1,0,1}就可以构造出一组解。

那么$x_i̸=0$的点（儿子数为偶）每个儿子的子树需要两两配对$(a,b)$，使得$Subtre{e}_{ax}=-Subtre{e}_{bx}$，此时$Subtre{e}_{ix}=x_i$；$x_i=0$的点（儿子数为奇）则是两两配对后剩下一个点$c$，继续上传等价于$Subtre{e}_{cx}$。

分别遍历两颗树，将每个点儿子($x_i̸=0$时也包括自己)任意组成点对，点对中的两个点在新图$G$中连一条边，并将剩下的一个点继续上传。

$G$不可能存在奇环，所以二分图染色，一边点$x_i=1$，另一边$x_i=-1$。

Code from ichneumon

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 100;

int n, fa[N], fb[N], is_odd[2][N];

struct Edge {
    int e, *h, *nx, *to, V, E;
    Edge(int V, int E):V(V), E(E) {
        e = 0;
        h = new int [V];
        nx = new int [E];
        to = new int [E];
        memset(h, -1, 4 * V);
    }
    ~Edge() {
        delete h;
        delete nx;
        delete to;
    }
    void clear() {
        e = 0;
        memset(h, -1, 4 * V);
    }
    void add(int u, int v) {
        to[e] = v, nx[e] = h[u], h[u] = e++;
        to[e] = u, nx[e] = h[v], h[v] = e++;
    }
} *tr, *bi;

int dfs(int u, int f) {
    vector<int> odd_son;
    for (int i = tr->h[u]; i != -1; i = tr->nx[i]) {
        int v = tr->to[i];
        if (v != f) {
            v = dfs(v, u);
           // if (v != 0)
                odd_son.push_back(v);
        }
    }
    if (!is_odd[0][u])
        odd_son.push_back(u);
    for (int i = 0; i < (int)odd_son.size() - 1; i += 2) {
        bi->add(odd_son[i], odd_son[i + 1]);
    }
    return odd_son.size() % 2 == 0 ? 0 : odd_son.back();
}

bool vis[N], col[N];

void coloring(int u, int c) {
    vis[u] = true;
    col[u] = c;
    for (int i = bi->h[u]; i != -1; i = bi->nx[i]) {
        int v = bi->to[i];
        if (!vis[v])
            coloring(v, c ^ 1);
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &fa[i]);
        if (fa[i] != -1) {
            is_odd[0][fa[i]] ^= 1;
        }
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &fb[i]);
        if (fb[i] != -1)
            is_odd[1][fb[i]] ^= 1;
    }
    for (int i = 1; i <= n; ++i) {
        if (is_odd[0][i] ^ is_odd[1][i]) {
            puts("IMPOSSIBLE");
            return 0;
        }
    }
    tr = new Edge(n + 1, (n + 1) * 2);
    bi = new Edge(n + 10, (n + 10) * 4);
    int rt;
    for (int i = 1; i <= n; ++i) {
        if (fa[i] == -1) {
            rt = i;
            continue;
        }
        tr->add(i, fa[i]);
    }
    dfs(rt, -1);
    tr->clear();
    for (int i = 1; i <= n; ++i) {
        if (fb[i] == -1) {
            rt = i;
            continue;
        }
        tr->add(i, fb[i]);
    }
    dfs(rt, -1);
    for (int i = 1; i <= n; ++i)
        if (!vis[i]) {
            coloring(i, 1);
        }
    puts("POSSIBLE");
    for (int i = 1; i <= n; ++i) {
        if (is_odd[0][i]) {
            printf("%d ", 0);
        } else {
            printf("%d ", col[i] ? 1 : -1);
        }
    }
    puts("");

    return 0;
}