出题人
如果 \(\exists a_i\equiv0\bmod 2\) 那么可以让 \(b_i=\frac{a_i}2\)，剩下的 \(b_j=a_j-b_i\)
其实问题就是找到一个 \(\{a\}\) 的子集 \(S\) 使得存在 \(b\) 满足 \(b_1+b_2=S_1,b_2+b_3=S_2,\dots b_{|S|}+b_1=S_{|S|}\)
这时候 \(S\) 注意这里的等式一定是全集构成一个整环而不存在枝杈，否则让基环森林里面的任意一个环满足即可
继续观察上面的等式发现：由于 \(S_i\) 全是奇数所以 \(|S|\) 是偶数，将 \(S_i\) 按照下标奇偶性分成两组，那么两组的和均为 \(\sum b\)
那么现在问题就是在 \(\{a\}\) 中找到两个权值和大小都相同的子集，通过枚举子集的方式可以规避三进制，使用哈希表存储信息即可
卡常技巧包括但不限于将使用哈希表的一侧大小设为 \(\frac{n}2-2\) 或者当程序运行时间超过阀值输出 NO
Code Display
const int N=400;
int n,a[N],b[N],v[N];
pair<int,int> ans[N];
unordered_map<int,pair<int,int> > mp[N];
int sum1[1<<15],sum2[1<<17];
signed main(){
freopen("problemsetter.in","r",stdin); freopen("problemsetter.out","w",stdout);
n=read();
rep(i,1,n) a[i]=read();
rep(i,1,n) if(a[i]%2==0){
puts("Yes");
vector<int> b={a[i]/2};
vector<pair<int,int> > ans;
rep(j,1,n){
if(i==j) ans.emplace_back(1,1);
else{
b.emplace_back(a[j]-b[0]);
ans.emplace_back(1,b.size());
}
}
rep(e,0,n-1) print(b[e]); putchar('\n');
rep(e,0,n-1) print(ans[e].fir),print(ans[e].sec),putchar('\n');
exit(0);
}
if(n<=2) puts("No"),exit(0);
int n1=max(1ll,n/2-2),n2=n-n1;
int U1=1<<n1,U2=1<<n2;
rep(s,1,U1-1){
int lb=s&(-s),id=__builtin_ctzll(lb)+1;
sum1[s]=sum1[s^lb]+a[id];
}
rep(i,n1+1,n) b[i-n1]=a[i];
rep(s,1,U2-1){
int lb=s&(-s),id=__builtin_ctzll(lb)+1;
sum2[s]=sum2[s^lb]+b[id];
}
auto output=[&](const pair<int,int> S,const pair<int,int> T){
if(S.fir+S.sec+T.sec+T.fir==0) return ;
vector<pair<int,int> >Plu,Min;
for(int i=1;i<=n1;++i){
if(S.fir>>(i-1)&1) Plu.emplace_back(a[i],i);
if(S.sec>>(i-1)&1) Min.emplace_back(a[i],i);
}
for(int i=1;i<=n2;++i){
if(T.fir>>(i-1)&1) Plu.emplace_back(b[i],i+n1);
if(T.sec>>(i-1)&1) Min.emplace_back(b[i],i+n1);
}
sort(Plu.begin(),Plu.end());
sort(Min.begin(),Min.end());
int num=0,cur=0;
b[++num]=cur;
int siz=Plu.size();
while(Min.size()||Plu.size()){
if(Plu.size()==Min.size()){
cur=Plu.back().fir-cur;
ans[Plu.back().sec]={num,num+1};
Plu.pop_back();
}else{
cur=Min.back().fir-cur;
ans[Min.back().sec]={num,num==siz*2?1:num+1};
Min.pop_back();
}
if(num<siz*2) b[++num]=cur;
}
for(int i=1;i<=n;++i) if(!ans[i].fir){
ans[i]={1,++num};
b[num]=a[i]-b[1];
}
puts("Yes");
for(int i=1;i<=n;++i) print(b[i]); putchar('\n');
for(int i=1;i<=n;++i) print(ans[i].fir),print(ans[i].sec),putchar('\n');
exit(0);
};
rep(S,0,U1-1){
for(int T=S;;T=(T-1)&S){
int num=__builtin_popcount(T)-__builtin_popcount(S^T);
mp[n+num][sum1[T]-sum1[S^T]]=make_pair(T,S^T);
if(!T) break;
}
}
rep(S,0,U2-1){
for(int T=S;;T=(T-1)&S){
int num=__builtin_popcount(T)-__builtin_popcount(S^T);
if(mp[n-num].count(-sum2[T]+sum2[S^T])){
output(mp[n-num][-sum2[T]+sum2[S^T]],make_pair(T,S^T));
}
if(!T) break;
}
if(1.0*clock()/CLOCKS_PER_SEC>1.6) break;
}
puts("No");
return 0;
}
彩色挂饰
建立圆方树，设 \(f_{x,c}\) 表示 \(x\) 或 \(x\) 表示点双的根的颜色为 \(c\) 时最少的联通块数
对于实点 \(x\) 可以直接合并下辖虚点的信息即 \(\sum_{v} f_{v,c}\)
对于虚点 \(x\) 需要对联通分量里面的异色联通块数进行计算：
预处理出来点双里面每个子集的导出子图形成的联通块数量，以及每个子集填入哪种合法的颜色形成的联通块最少，再进行一个枚举子集再枚举子集填哪种颜色的 \(\rm DP\) 来计算贡献
常见的建立圆方树的过程就能让父亲作为方点出边 vector 中的第一个点，要注意添加子集的过程中强制让包含 \(1\) 元素的子集填成所需颜色
注意这样的统计方式每个方点的父亲会被算两次，但是根这个实点只会被算一次，需要根据实际含义再加加减减
Code Display
const int N=2e5+10,inf=2e5+10;
int n,m,k,s;
vector<int> G[N],g[N];
int dp[N][25];
int col[N][64],con[N][64];
int dfn[N],low[N],stk[N],top,nds,tim;
int fa[N],ini[N];
unordered_set<int> edge[N];
bool exi[10][10];
inline int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
inline void tarjan(int x){
dfn[x]=low[x]=++tim; stk[++top]=x;
for(auto t:g[x]){
if(!dfn[t]){
tarjan(t); ckmin(low[x],low[t]);
if(low[t]>=dfn[x]){
++nds;
G[nds].emplace_back(x);
G[x].emplace_back(nds);
do{
G[nds].emplace_back(stk[top]);
G[stk[top]].emplace_back(nds);
--top;
}while(stk[top+1]!=t);
int siz=G[nds].size(),U=1<<siz;
for(int i=0;i<siz;++i){
for(int j=i+1;j<siz;++j){
exi[i][j]=exi[j][i]=edge[G[nds][i]].find(G[nds][j])!=edge[G[nds][i]].end();
}
}
for(int i=0;i<U;++i){
for(int j=0;j<siz;++j) if(i>>j&1){
int t=G[nds][j];
fa[j]=j;
if(ini[t]){
if(!col[nds][i]) col[nds][i]=ini[t];
else if(col[nds][i]!=ini[t]) col[nds][i]=-1;
}
}
for(int j=0;j<siz;++j) if(i>>j&1){
for(int k=j+1;k<siz;++k) if(i>>k&1){
if(exi[j][k]) fa[find(j)]=find(k);
}
}
for(int j=0;j<siz;++j) if(i>>j&1) con[nds][i]+=fa[j]==j;
}
}
}else ckmin(low[x],dfn[t]);
}
return ;
}
inline int solve(int x,int fat,int c){
if(~dp[x][c]) return dp[x][c];
if(x<=n){
int sum=0;
for(auto t:G[x]) if(t!=fat) sum+=solve(t,x,c);
return dp[x][c]=sum;
}
if(ini[fat]&&ini[fat]!=c) return dp[x][c]=inf;
int num=G[x].size(),U=1<<num; --U;
int dp1[64],dp2[64][25];
rep(i,0,k) dp2[0][i]=0;
for(int i=1;i<=U;++i){
dp2[i][0]=inf;
int lb=i&(-i),id=__builtin_ctzll(lb);
for(int c=1;c<=k;++c){
if(G[x][id]==fat) dp2[i][c]=dp2[i^lb][c];
else dp2[i][c]=dp2[i^lb][c]+solve(G[x][id],x,c);
ckmin(dp2[i][0],dp2[i][c]);
}
}
dp1[0]=0;
for(int S=1;S<=U;++S){
dp1[S]=inf;
for(int T=S;T;T=(T-1)&S){
if(col[x][T]==-1) continue;
int cur=col[x][T];
if(T&1){
if(cur!=c&&cur) continue;
cur=c;
}
ckmin(dp1[S],dp1[S^T]+con[x][T]+dp2[T][cur]);
}
}
return dp[x][c]=dp1[U];
}
signed main(){
freopen("colorful.in","r",stdin); freopen("colorful.out","w",stdout);
nds=n=read(); m=read(); k=read(); read();
for(int i=1;i<=n;++i) ini[i]=read();
for(int i=1;i<=m;++i){
int u=read(),v=read();
edge[u].insert(v);
edge[v].insert(u);
g[u].emplace_back(v);
g[v].emplace_back(u);
}
for(int i=1;i<=n;++i) if(!dfn[i]) tarjan(i);
memset(dp,-1,sizeof(dp));
int val=inf;
if(ini[1]) val=solve(1,0,ini[1]);
else rep(i,1,k) ckmin(val,solve(1,0,i));
print(val-(nds-n)+1);
return 0;
}
逆转函数
预处理每个 \(i\) 的上一次下一次的出现位置 \(pre_i,nxt_i\)，那么 \([l,r]\) 存在逆转函数等价于 \(r-l\le 1\) 或者以下三个条件都满足:
-
\([l+1,r-1]\) 存在逆转函数
-
\(pre_r\le l\) 或者 \(a_l=a_{l+r-pre_r}\)
-
\(nxt_l\ge r\) 或者 \(a_r=a_{l+r-nxt_r}\)
注意到这种判定方式和回文串类似，而所求是每个 “类回文区间” 的 \(m^{m-n(l,r)}\) 的和，用 \(\rm Manacher\) 来做，计算每个点作为回文中心时对答案的贡献
将 \([l,r]\) 扩展成 \([l-1,r+1]\) 时维护 \(n(l,r)\) 以及新增的对答案的贡献是平凡的，但是在继承时存在两者取 \(\min\) 的操作会让信息减少，那么先继承 \(2i-mid\) 的信息，再减至 mid+r[mid] 处，信息的减少和增加的处理方式一样
观察到如果保留最靠右的 \(i+r_i\) 的 \(i\) 则 \(i-r_i\) 是不断右移的，而扩展本身会让最靠右的回文串的右端点右移，那么复杂度就是 \(\Theta(n)\) 的
Code Display
const int N=6e5+10;
int a[N],pw[N],n,m;
int pre[N],lst[N],nxt[N];
int num[N],sum[N],r[N];
signed main(){
freopen("invfunc.in","r",stdin); freopen("invfunc.out","w",stdout);
n=read(); m=read();
for(int i=1;i<=n;++i) a[i]=read();
for(int i=n;i>=1;--i) a[i<<1]=a[i];
rep(i,1,n*2+1) if(i&1) a[i]=m+1;
pw[0]=1;
for(int i=1;i<=n*2+1;++i){
pw[i]=mul(pw[i-1],m);
pre[i]=lst[a[i]];
lst[a[i]]=i;
}
for(int i=1;i<=m+1;++i) lst[i]=n*2+2;
for(int i=n*2+1;i>=1;--i){
nxt[i]=lst[a[i]];
lst[a[i]]=i;
}
auto check=[&](int l,int r){
if(r-l<=1) return true;
if(!l||r>2*n+1) return false;
if(pre[r]>l&&a[l]!=a[l+r-pre[r]]) return false;
if(nxt[l]<r&&a[r]!=a[l+r-nxt[l]]) return false;
return true;
};
int ans=0,cen=num[1]=1;
for(int i=2;i<=n*2;++i){
if(i<=cen+r[cen]){
r[i]=r[2*cen-i];
sum[i]=sum[2*cen-i];
num[i]=num[2*cen-i];
while(i+r[i]>cen+r[cen]){
if((i+r[i])&1) ckdel(sum[i],pw[m+1-num[i]]);
int lef=cen*2-i-r[i],rig=cen*2-i+r[i];
if(nxt[lef]>rig) --num[i];
if(pre[rig]<lef+1) --num[i];
--r[i];
}
}else num[i]=1;
while(check(i-r[i]-1,i+r[i]+1)){
++r[i];
if(nxt[i-r[i]]>i+r[i]-1) ++num[i];
if(pre[i+r[i]]<i-r[i]) ++num[i];
if((i+r[i])&1) ckadd(sum[i],pw[m+1-num[i]]);
}
if(i+r[i]>=cen+r[cen]) cen=i;
ckadd(ans,sum[i]);
}
print(ans);
return 0;
}