9.11 test

题面.pdf

T1:
通过打表发现，从一个点出发只有距离为1,2,3,5,6,9,10,13,17的点才不能到达；

那么我们转移的时候只有距离在20以内才不一定能直接转移，那么我们离散化之后;

对于每一个矿往前for 20个，然后特判距离是否合法进行转移即可；

//MADE BY QT666
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int N=200050;
int tot,hsh[N],a[N],v[N],b[N],n,m;
int dp[N];
bool check(int x){
    if(x==1||x==2||x==3||x==5||x==6||x==9||x==10||x==13||x==17) return 0;
    return 1;
}
int main(){
    freopen("mining.in","r",stdin);
    freopen("mining.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
	scanf("%d%d",&a[i],&b[i]);
	hsh[++tot]=b[i];
    }
    sort(hsh+1,hsh+1+tot);tot=unique(hsh+1,hsh+1+tot)-hsh-1;
    for(int i=1;i<=n;i++){
	b[i]=lower_bound(hsh+1,hsh+1+tot,b[i])-hsh;
	v[b[i]]+=a[i];
    }
    for(int i=1;i<=tot;i++) dp[i]=-(1e9+1);
    for(int i=1;i<=tot;i++){
	    for(int j=max(0,i-20);j<i;j++){
		if(check(hsh[i]-hsh[j])) dp[i]=max(dp[i],dp[j]+v[i]);
	    }
    }
    int ans=0;
    for(int i=1;i<=tot;i++) /*cout<<hsh[i]<<' '<<dp[i]<<endl,*/ans=max(ans,dp[i]);
    printf("%d\n",ans);
    return 0;
}

T2:

首先因为方差只会越变越大，所以可以加剪枝进行搜索，但是双向搜索还是无法100%；

考虑到把答案的式子拆开变为(n+m-1)*∑ai^2-sum*sum，我们发现答案只和sum和∑ai^2这两个量有关；

那么我们可以用一种很套路的动态规划，在状态中开一维表示其中一个量，然后用dp的转移过程中，求出该状态下另一个量的最优；

那么我们设dp[i][j][k],表示到i行j列，sum为k的，∑ai^2的最小值，然后转移就是很simple了，最后枚举第三维的状态，然后算出该状态下的最优值；

//MADE BY QT666
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int N=2000;
int a[40][40],dp[40][40][N],T,n,m;
int main(){
    freopen("matrix.in","r",stdin);
    freopen("matrix.out","w",stdout);
    scanf("%d",&T);
    while(T--){
	int n,m;scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
	    for(int j=1;j<=m;j++) scanf("%d",&a[i][j]);
	}
	memset(dp,127/3,sizeof(dp));int sum=30*(n+m-1);
	dp[1][1][a[1][1]]=a[1][1]*a[1][1];
	for(int i=1;i<=n;i++){
	    for(int j=1;j<=m;j++){
		for(int k=0;k<=sum;k++){
		    if(dp[i][j][k]==dp[0][0][0]) continue;
		    if(i+1<=n) dp[i+1][j][k+a[i+1][j]]=min(dp[i+1][j][k+a[i+1][j]],dp[i][j][k]+a[i+1][j]*a[i+1][j]);
		    if(j+1<=m) dp[i][j+1][k+a[i][j+1]]=min(dp[i][j+1][k+a[i][j+1]],dp[i][j][k]+a[i][j+1]*a[i][j+1]);
		}
	    }
	}
	int ans=dp[0][0][0];
	for(int i=1;i<=sum;i++){
	    if(dp[n][m][i]==dp[0][0][0]) continue;
	    ans=min(ans,(n+m-1)*dp[n][m][i]-i*i);
	}
	printf("%d\n",ans);
    }
}

T3:

首先M=0的做法，就是以父亲来转移,ans[x]=ans[fa[x]-size[x]*w+(n-size[x])*w;

然我们考虑M不为0的情况，因为M很小，二进制中只有4位，那么我们把一个二进制数分成两边来计算；

后4位中的是要受xor影响的，但是前面都是不用管xor的影响的；

那么我们对于一个x开两个数组，sum[x]表示除开后4位的数值，(最后算答案的时候<<4)，f[x][i](i=0~15)，表示跟x距离为i的点的数量；

那么我们考虑如何合并，其实相当于模拟二进制进位运算；

设父亲为 x+y,儿子为a+b,那么合并后相当于变为，((x+y)+(a+b)/16)+(a+b)%16;

也就是在加法的过程中处理进位，在具体处理过程中，我们考虑边的贡献来进行合并，因为相当于是儿子中所有距离要+w;

那么我们先考虑这个东西对前面的贡献，即(w/16)*size[son];

然后在考虑这个东西堆后面四位的贡献，即枚举0-15，+w,然后处理进位；

这样第一遍dfs就解决了子树内的问题，然后我们考虑父亲对儿子的贡献；

这里有一个常用技巧，就是用一个数组存下父亲除去该儿子的子树的答案，然后就可以“颠倒”父子关系，把父亲当儿子进行处理，处理方法就和第一遍dfs一样；

最后处理答案的时候就是前面的答案<<4，然后再把后面的0-15 xor m再乘以数量加入答案；

//MADE BY QT666
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
const int N=200050;
int dp[N][16],c[16],sum[N];
int head[N],to[N],nxt[N],v[N],cnt,dis[N],size[N],ans[N],n,m;
void lnk(int x,int y,int z){
    to[++cnt]=y,nxt[cnt]=head[x],v[cnt]=z,head[x]=cnt;
    to[++cnt]=x,nxt[cnt]=head[y],v[cnt]=z,head[y]=cnt;
}
void dfs1(int x,int f){
    dp[x][0]=1;size[x]=1;
    for(int i=head[x];i;i=nxt[i]){
	int y=to[i];if(y==f) continue;
	dfs1(y,x);int w=v[i];
	sum[x]+=sum[y]+(w/16)*size[y];
	int g=w%16;
	for(int j=0;j<=15;j++){
	    dp[x][(j+g)%16]+=dp[y][j];
	    sum[x]+=dp[y][j]*((j+g)/16);
	}
	size[x]+=size[y];
    }
}
void dfs2(int x,int f){
    ans[x]=sum[x]<<4;
    for(int i=0;i<=15;i++) ans[x]+=(i^m)*dp[x][i];
    for(int i=head[x];i;i=nxt[i]){
	int y=to[i];if(y==f) continue;
	int w=v[i],ret=sum[x]-sum[y]-(w/16)*size[y],g=w%16;
	memset(c,0,sizeof(c));
	for(int j=0;j<=15;j++){
	    ret-=dp[y][j]*((j+g)/16);
	    c[(j+g)%16]=dp[x][(j+g)%16]-dp[y][j];
	}
	ret+=(w/16)*(n-size[y]);
	for(int j=0;j<=15;j++){
	    dp[y][(j+g)%16]+=c[j];
	    sum[y]+=c[j]*((j+g)/16);
	}
        sum[y]+=ret;dfs2(y,x);
    }
}
int main(){
    freopen("warehouse.in","r",stdin);
    freopen("warehouse.out","w",stdout);
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++){
	int x,y,z;scanf("%d%d%d",&x,&y,&z);lnk(x,y,z);
    }
    dfs1(1,0);dfs2(1,0);
    for(int i=1;i<=n;i++) printf("%d\n",ans[i]-m);
    return 0;
}