\(A\)
根据裴蜀定理显然要\(k|\gcd(a_1,...,a_n)\),顺便注意不能造出大于\(\max(a_1,...,a_n)\)的数
int n,g,k,x,mx;
int main(){
scanf("%d%d",&n,&k);
fp(i,1,n)scanf("%d",&x),g=__gcd(g,x),cmax(mx,x);
puts(k%g==0&&k<=mx?"POSSIBLE":"IMPOSSIBLE");
return 0;
}
\(B\)
对每个人开一个指针,表示他是参加了哪个运动,然后每次把参加人数最多的运动强制不选,同时更新每个人的指针。一直做到指针越界为止,取最优值即可
//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int N=305;
int mp[N][N],cnt[N],id[N],bg[N],vis[N],res,mx,n,m;
int main(){
scanf("%d%d",&n,&m);
fp(i,1,n)fp(j,1,m)scanf("%d",&mp[i][j]);
fp(i,1,n)bg[i]=1,++cnt[mp[i][1]];
res=2333;
while(2333){
mx=0;fp(i,1,m)cmax(mx,cnt[i]);
cmin(res,mx);
fp(i,1,m)if(cnt[i]==mx)vis[i]=1;
fp(i,1,n)while(bg[i]<=m&&vis[mp[i][bg[i]]])++bg[i];
fp(i,1,n)if(bg[i]>m)return printf("%d\n",res),0;
fp(i,1,m)cnt[i]=0;
fp(i,1,n)++cnt[mp[i][bg[i]]];
}
return 0;
}
\(C\)
先考虑二维的情况,即总共有\(n=x+y\)个人,每个人有金币\(a_i\)或银币\(b_i\),那么先假设所有人都取银币,加上前\(x\)大的\(a_i-b_i\)就行了。如果总的个数大于\(n\),那么按\(a_i-b_i\)从大到小排序后,取金币的人必然全部在取银币的人的左边,即存在一个中间点\(k\),满足取金币的人在\([1,k]\),取银币的人在\([k+1,n]\)
对于三维,我们假设所有人都选铜币,并令\(a_i-=c_i,b_i-=c_i\),那么此时转化为之前那种二维的情况了,用堆维护就可以了
//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
#define gg(u) for(int &i=cur[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
typedef long long ll;
const int N=1e5+5;
ll f[N],g[N],sum,res;int a[N],b[N],c[N],id[N],x,y,z,n,sz;
priority_queue<int,vector<int>,greater<int> >q;
inline bool cmp(const int &x,const int &y){return a[x]-b[x]>a[y]-b[y];}
inline void ins(R int x){sum+=x,q.push(x),++sz;}
inline void del(){sum-=q.top(),q.pop(),--sz;}
int main(){
// freopen("testdata.in","r",stdin);
scanf("%d%d%d",&x,&y,&z),n=x+y+z;
fp(i,1,n){
scanf("%d%d%d",&a[i],&b[i],&c[i]);
a[i]-=c[i],b[i]-=c[i],id[i]=i;
}
sort(id+1,id+1+n,cmp);
sum=sz=0;while(!q.empty())q.pop();
fp(i,1,n){
ins(a[id[i]]);
while(sz>x)del();
if(sz==x)f[i]=sum;
}
sum=sz=0;while(!q.empty())q.pop();
fd(i,n,1){
ins(b[id[i]]);
while(sz>y)del();
if(sz==y)g[i]=sum;
}
res=-1e18;
fp(i,x,n-y)cmax(res,f[i]+g[i+1]);
fp(i,1,n)res+=c[i];
printf("%lld\n",res);
return 0;
}
\(D\)
我是个\(zz\)……
首先对于每条边,设它两边的\(size\)里较小的那个为\(s\),它的权值为\(w\),那么它的贡献上界是\(s\times w\),那么答案上界就是\(\sum s\times w\)
然而上界不可能达到的,我们考虑该减去那些
假设重心是一条边,即两边的\(size\)大小都是\({n\over 2}\),那么对于除了重心的这条边,我们都可以令它被经过次数达到上界,那么答案就是上界减去这条边的权值
假设重心是一个点,那么除了重心到某个子节点的一条边,我们也可以让这些边都达到上界,那么答案就是上界减去重心到子节点的边权中最小的就是了
//quming
#include<bits/stdc++.h>
#define R register
#define pb emplace_back
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
typedef long long ll;
typedef pair<ll,int> pi;
const int N=1e5+5;
struct eg{int v,nx,w;}e[N<<1];int head[N],tot;
inline void add(R int u,R int v,R int w){e[++tot]={v,head[u],w},head[u]=tot;}
inline int min(R int x,R int y){return x<y?x:y;}
ll res;int sz[N],rt,rv,op,mmx,n;
void dfs(int u,int fa,ll dis){
sz[u]=1;
R int mx=0;
go(u)if(v!=fa){
dfs(v,u,dis+e[i].w),sz[u]+=sz[v];
res+=1ll*min(sz[v],n-sz[v])*e[i].w<<1;
if((sz[v]<<1)==n)op=1,rv=e[i].w;
cmax(mx,sz[v]);
}
cmax(mx,n-sz[u]);
if(cmin(mmx,mx))rt=u;
}
int main(){
// freopen("testdata.in","r",stdin);
scanf("%d",&n),mmx=n+1;
for(R int i=1,u,v,w;i<n;++i){
scanf("%d%d%d",&u,&v,&w);
add(u,v,w),add(v,u,w);
}
dfs(1,0,0);
if(op&1)res-=rv;
else{
R int mn=0x3f3f3f3f;
go(rt)cmin(mn,e[i].w);
res-=mn;
}
printf("%lld\n",res);
return 0;
}
\(E\)
越来越觉得自己好蠢了……
我们先从原点开始考虑,设\(c(x,y)\)表示从原点到\(x,y\)的方案数\((x\geq 0,y\geq 0)\),这个显然为\({x+y\choose x}\)
然后开始推倒
\[ \begin{aligned} \sum_{y=0}^Y c(X,y)=c(X+1,Y) \end{aligned} \]
就是说走到\((X+1,Y)\)的方案,就等价于我们枚举在第\(X\)行的哪一列往下走再往右
\[ \begin{aligned} \sum_{x=0}^X\sum_{y=0}^Y c(x,y)=c(X+1,Y+1)-1 \end{aligned} \]
用前面那个柿子带进去就可以了
\[ \begin{aligned} \sum_{x=X_1}^{X_2}\sum_{y=Y_1}^{Y_2} c(x,y)=C(X_2+1,Y_2+1)-c(X_1,Y_2+1)-c(X_2+1,Y_1)+c(X_1,Y_1) \end{aligned} \]
相当于是子矩阵求和,那么变成四个前缀和减一减就好了
然后我们发现一个矩阵可以拆成四个单点求和的形式!
然后我们考虑,起点,中间点,终点的范围都是一个矩阵,如果我们枚举中间点,那么就可以把起点和终点的求和给拆成四个单点的形式,这样就可以\(O(16)\)计算一个中间点的贡献了
考虑如果一条路径经过中间点的那个矩阵,那么贡献就是这条路径和矩阵相交的点的个数,也就是说这条路径要乘上这个个数
我们枚举这条路径是从哪里进矩阵的,从哪里出矩阵的,假设分别是从\((x,y)\)进且从\((xx,yy)\)出,那么贡献就是\(xx-x+yy-y+1\)
那么我们只枚举路径进矩阵的位置,对于路径数乘上\((-x-y)\),再枚举路径出矩阵的位置,对于路径数乘上\(xx+yy+1\),这样我们发现每条合法的路径都会被计算恰好贡献次,所以就没问题了
//quming
#include<bits/stdc++.h>
#define R register
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int P=1e9+7;
inline void upd(R int &x,R int y){(x+=y)>=P?x-=P:0;}
inline int add(R int x,R int y){return x+y>=P?x+y-P:x+y;}
inline int dec(R int x,R int y){return x-y<0?x-y+P:x-y;}
inline int mul(R int x,R int y){return 1ll*x*y-1ll*x*y/P*P;}
int ksm(R int x,R int y){
R int res=1;
for(;y;y>>=1,x=mul(x,x))(y&1)?res=mul(res,x):0;
return res;
}
const int N=2e6+5;
int fac[N],ifac[N];
void init(int n=2e6){
fac[0]=ifac[0]=1;fp(i,1,n)fac[i]=mul(fac[i-1],i);
ifac[n]=ksm(fac[n],P-2);fd(i,n-1,1)ifac[i]=mul(ifac[i+1],i+1);
}
inline int C(R int n,R int m){return m>n?0:1ll*fac[n]*ifac[m]%P*ifac[n-m]%P;}
inline int calc(R int x,R int y,R int xx,R int yy){
R int res=C(x+y,x);
upd(res,C(xx+1+yy+1,xx+1));
upd(res,P-C(x+yy+1,x));
upd(res,P-C(y+xx+1,y));
return res;
}
int x[15],y[15],res;
inline int t1(R int xx,R int yy){
return calc(xx-x[2],yy-y[2],xx-x[1],yy-y[1]);
}
inline int t2(R int xx,R int yy){
return calc(x[5]-xx,y[5]-yy,x[6]-xx,y[6]-yy);
}
int main(){
// freopen("testdata.in","r",stdin);
init();
fp(i,1,6)scanf("%d",&x[i]);
fp(i,1,6)scanf("%d",&y[i]);
fp(i,x[3],x[4]){
upd(res,1ll*(P-y[3]-i)*t1(i,y[3]-1)%P*t2(i,y[3])%P);
upd(res,1ll*(y[4]+1+i)*t1(i,y[4])%P*t2(i,y[4]+1)%P);
}
fp(j,y[3],y[4]){
upd(res,1ll*(P-x[3]-j)*t1(x[3]-1,j)%P*t2(x[3],j)%P);
upd(res,1ll*(x[4]+1+j)*t1(x[4],j)%P*t2(x[4]+1,j)%P);
}
printf("%d\n",res);
return 0;
}
\(F\)
首先根据每个点的子节点的个数,是可以判断该节点需要填奇数还是偶数的,如果这个奇偶性在两棵树上不同那么显然无解了
否则的话,对于偶节点,我们令其为\(0\),对于每个奇节点的子树中一定有\(2k+1\)个奇节点,我们把这些搞成\(k\)组匹配,对于\((u,v)\)的一组匹配,令\(a_u=1,a_v=-1\)就行了这样子树中的总和的绝对值一定是\(1\)
而对于我们连的边,它一定是一个二分图(否则就会有一个点连了两条边且来自同一棵子树),那么直接黑白染色确定方案就行了
//quming
#include<bits/stdc++.h>
#define R register
#define pb emplace_back
#define fp(i,a,b) for(R int i=(a),I=(b)+1;i<I;++i)
#define fd(i,a,b) for(R int i=(a),I=(b)-1;i>I;--i)
#define go(u) for(int i=head[u],v=e[i].v;i;i=e[i].nx,v=e[i].v)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
const int N=2e5+5;
struct eg{int v,nx;}e[N<<1];int head[N],tot;
inline void add(R int u,R int v){e[++tot]={v,head[u]},head[u]=tot;}
vector<int>t1[N],t2[N];
int a1[N],a2[N],st[N],b[N],rt1,rt2;
int n,top;
void dfs1(int u){
for(auto v:t1[u])dfs1(v);
if(a1[u])st[++top]=u;
while(top>=2){
add(st[top],st[top-1]),add(st[top-1],st[top]);
top-=2;
}
}
void dfs2(int u){
for(auto v:t2[u])dfs2(v);
if(a2[u])st[++top]=u;
while(top>=2){
add(st[top],st[top-1]),add(st[top-1],st[top]);
top-=2;
}
}
void dfs(int u,int c){
b[u]=c;
go(u)if(!b[v])dfs(v,-c);
}
int main(){
scanf("%d",&n);
fp(i,1,n)a1[i]=a2[i]=1;
for(R int i=1,fa;i<=n;++i){
scanf("%d",&fa);
if(fa==-1)rt1=i;else t1[fa].pb(i),a1[fa]^=1;
}
for(R int i=1,fa;i<=n;++i){
scanf("%d",&fa);
if(fa==-1)rt2=i;else t2[fa].pb(i),a2[fa]^=1;
}
fp(i,1,n)if(a1[i]!=a2[i])return puts("IMPOSSIBLE"),0;
puts("POSSIBLE");
top=0,dfs1(rt1);
top=0,dfs2(rt2);
fp(i,1,n)if(a1[i]&&!b[i])dfs(i,1);
fp(i,1,n)printf("%d ",b[i]);
return 0;
}