2019牛客暑期多校训练营 | 第八场解题报告（A、B、C）

A-All-one Matrices

给出一个01矩阵，求矩阵中元素全是1的极大子矩阵的个数。
求极大子矩阵比较常用的是建立一个“扫描线”模型，就是把矩阵中的一个点往上的最大通路作为一条悬线，然后把这条竖线左右移动确定左右边界，就可以确定当前点上子矩阵的极大值。
那么我们具体要怎么实现呢？对于每一个格子(i,j)，我们用up数组来保存每个格子上悬线的高度，对每一个up值，还需要维护其左边界left和右边界right。
维护左右边界的方法有两种（两种方法代码均给出），一种是dp写法，状态转移方程为Right：min(Right[i][j]，RIght[i-1],[j]) Left:：max(Left[i][j]，Left[i-1][j]) 。另一种是用单调栈，从左往右扫一遍每个格子的up值，储存在一个单调增栈里，当有元素退栈时，说明这条悬线可以经过这里了，直到栈顶的值小于当前悬线的值或者栈顶为空的时，当前栈顶的位置就是悬线的边界，右边界同理。
找到边界之后之后就开始判重操作了，这里依然要维护一个单调增栈，进行退栈操作之后，如果当前格子的up值与栈顶对应的up值相等时，就代表这个子矩阵已经判断过了，直接跳过。除此之外，还需要判断下边界是否可以扩展，方法是在预处理中用sum数组存矩阵每一行的前缀和，然后计算下一行中左右边界的前缀和差是否为边界的距离（即下一行位置元素全是1，可以向下扩展）。
写了这么多，下面还是给出代码吧。

1.DP判断左右边界

#include<cstdio>
#include<stack>
using namespace std;
const int maxn = 3010;
int mp[maxn][maxn];
int sum[maxn][maxn];//前缀和
int up[maxn][maxn];//向上延伸高度 
int left[maxn][maxn];//左边界
int right[maxn][maxn];//右边界 
char str[maxn]; 

stack<int> s;

void clear(void){
	while( !s.empty() ){
		s.pop();
	}
	return;
}

int main(void){
	int n,m;
	int lo;
	int ro; 
	int ans=0;
	scanf("%d%d",&n,&m);
	getchar();	
	for(int i=0; i<n; i++){
		lo=-1;
		ro=m;
		scanf("%s",str);	
		for(int j=0; j<m; j++){
			mp[i][j] = str[j] - '0';
			sum[i][j] = j==0 ? mp[i][j] : sum[i][j-1] + mp[i][j];
			if( mp[i][j]==1 ){
				up[i][j] = i==0 ? 1 : up[i-1][j] + 1;
				left[i][j] = i==0 ? lo +1 : max( lo+1, left[i-1][j]);
			}else{
				up[i][j] = 0;
				left[i][j] = 0;
				lo=j; 
			}
		}
		
		for(int j=m-1; j>=0; j--){
			if( mp[i][j]==1 ){
				right[i][j] = i==0 ? ro-1 : min( ro-1,right[i-1][j]);
			}else{
				right[i][j] = m-1;
				ro=j;
			}
		}		
	}

	//这个判重写法是错误的，因为只考虑了相邻两个格子间同一高度的情况,有可能出现两个相同高度间有一个更大高度的情况 
/* 	for(int i=0; i<n; i++){
		for(int j=0; j<m; j++){
			if(j<m-1 && left[i][j]==left[i][j+1] && right[i][j]==right[i][j+1] ){
				continue; 
			}//左右边界判重
			int l=left[i][j];
			int r=right[i][j];
			if( mp[i][j] ){			
				if( l>0 && !(i<n-1 && r-l+1 == sum[i+1][r] - sum[i+1][l-1] ) ){
					ans++;
				}				
				if( l==0 && !(i<n-1 && r-l+1 == sum[i+1][r]) ){
					ans++;
				}				
			} //下边界判重
 			 
		}	
	}  */
	
	//用单调栈判断扫描线是否能向左延伸 
	for( int i=0; i<n; i++){
		for(int j=0; j<m; j++){
			if( up[i][j]==0 ){
				clear();
				continue;
			}
			while( !s.empty() && up[i][j] < up[i][s.top()] ){
				s.pop();
			}
			if( s.empty() || up[i][j] > up[i][s.top()] ){
				int l = left[i][j];
				int r = right[i][j];
				if( sum[i+1][r] - sum[i+1][l-1] != r-l+1 ){
					ans++;		
				}
				s.push(j);				
			}
		}
		clear();
	}
	printf("%d",ans);
	
	return 0;
} 

2.单调栈判断左右边界

#include<cstdio>
#include<stack>
using namespace std;
const int maxn = 3010;
int mp[maxn][maxn];
int sum[maxn][maxn];//前缀和
int up[maxn][maxn];//向上延伸高度 
int left[maxn];//左边界
int right[maxn];//右边界 
char str[maxn];

stack<int> s;

void clear(void){
	while( !s.empty() ){
		s.pop();
	}
	return;
}

int main(void){
	int n,m;
	int lo;
	int ro; 
	int ans=0;
	scanf("%d%d",&n,&m);
	getchar();	
	for(int i=1; i<=n; i++){
		lo=-1;
		ro=m;
		scanf("%s",str);
		for(int j=1; j<=m; j++){
			mp[i][j] = str[j-1] - '0';
			if( mp[i][j] ){
				up[i][j] = up[i-1][j] + 1;
				sum[i][j] = sum[i][j-1]+1;				
			}else{
				up[i][j]=0;
				sum[i][j] = sum[i][j-1];
			}

		}
	}
	
	//用单调增栈处理计算左区间和右区间 
	for(int i=1; i<=n; i++){
		s.push(0);
		for(int j=1; j<=m; j++){
			while( !s.empty() && up[i][j] <= up[i][s.top()] ){
				s.pop();
			}
			if( s.empty() ){
				left[j]=1;
			}else{
				left[j]=s.top()+1;
			}
			s.push(j);
		} 
		clear();
		
		s.push(m+1);
		for(int j=m; j>=1; j--){
			while( !s.empty() && up[i][j] <= up[i][s.top()] ){
				s.pop();
			}
			if( s.empty() ){
				right[j]=m;
			}else{
				right[j]=s.top()-1;
			}
			s.push(j);
		} 
		clear();

		for (int j = 1; j <= m; j++){
            if (up[i][j] == 0) {
                clear();
                continue;
            }
            while (!s.empty() && up[i][j] < up[i][s.top()])
                s.pop();
            if (s.empty() || up[i][j] != up[i][s.top()]) {
                int l = left[j];
                int r = right[j];
                if (sum[i +1][r] - sum[i + 1][l - 1] != r - l + 1)
                    ans++;
                s.push(j);
            }
		}
		clear();
	}
	printf("%d",ans);
	return 0;
} 

B-Beauty Values

给出一个序列，序列内每个子区间出现的数字总数记为区间的值，求该序列所有子区间值的和。
用了不少时间来理解这个思路，主要是通过统计每一个数字的对总数的贡献值。当序列不存在相同的数字时，贡献值即为存在区间数。如果在这个数字之前存在相同的数字，贡献值需要减去上一个已经计算过的贡献值。如表格中的第三列的数字1，其中有3*1个区间与第一个1重复了，所以在这里需要减去重复计算的贡献值。

#include<cstdio>
#include<iostream>
#include<stack>
using namespace std;
typedef long long LL;

int d[100010];

int main(void){
	int n;
	int x;
	LL ans=0;
	scanf("%d",&n);
	for(int i=1; i<=n; i++){
		scanf("%d",&x);
		ans += (n-i+1)*(i-d[x]);
		d[x]=i;
	}
	printf("%lld",ans);


	return 0; 
}

C-CDMA

构造题，求构造一个大小为2^k× 2^k的1-1矩阵，且矩阵任意两行的内积为0.。
神仙队友提供了一个类似分治的思路，把第一行设置为全都是1，那么接下来的所有行的数字必须为一半为1一半为-1，确定了1和-1的数量之后，我们怎么安排1和-1的位置呢？
我们先把第二行从中间分成两半，把第一行作为“参照行”，取前一半数字与参照行相同，后数字一半与参照行相反，这样就能保证一二行内积为零。第三、四行则分成四段，把第二行作为参照行，一三段数字相同，二四段数字相反，第四行一四段相同，二四段相反，以此类推。这样就能通过保证每个小段的内积为0，从而使两行间的内积为0。文字表述可能不太清楚，这里放上例子。

8×8的矩阵情况应该是：
1 1 1 1 1 1 1 1
-1 -1 -1 -1 1 1 1 1
1 1 -1 -1 -1 -1 1 1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 1 -1 -1 1
-1 1 -1 1 1 -1 1 -1
-1 1 1 -1 -1 1 1 -1
-1 1 -1 1 -1 1 -1 1

附上代码：

#include<cstdio>
const int maxn = 1050;
using namespace std;

int mp[maxn][maxn];

int main(void){
	int n;
	int i,j;
	int pre;
	int d;//连续子区间长度 
	scanf("%d",&n);
	for( i=0,j=0; j<n; j++){
		mp[i][j]=1;
	}
	for( i=1,j=0; j<n; j++){
		if( j<n/2 ){
			mp[i][j]=mp[i-1][j];
		}else{
			mp[i][j]=-mp[i-1][j];
		}
	}	
	for( i=2; i<n; i+=2){
		pre = i/2;
		d = n/2;
		int t = pre;
		do{
			d/=2;
			t/=2;
		}while(t>=1);
		for( j=0; j<n; j++ ){
			if( ((j+d)/d)%2==1 ){
				mp[i][j]=mp[pre][j];
				mp[i+1][j]=mp[pre][j];								
			}else{
				mp[i][j]=-mp[pre][j];
				mp[i+1][j]=-mp[pre][j];										
			}
			if( (j+2*d)/(2*d) % 2==0 ){
				mp[i+1][j]*=-1;
			}			
		}
		/*
		for( j=0; j<n; j++){
			printf("%d ",mp[i][j]);
		}
		printf("\n");
		for( j=0; j<n; j++){
			printf("%d ",mp[i+1][j]);
		}
		printf("\n");*/			
			
	}
	for( i=0; i<n; i++){
		for( j=0; j<n; j++){
			printf("%d ",mp[i][j]);
		}
		printf("\n");
	}	
	return 0;
}