2019 kickstart round H

H-Index

題意：對於一個數組，對於每個$i( 1\leq i \leq n)$，找到一個數字$H$，使得$a_{1}...a_{i}$中大於等於$H$的數字的出現的次數也大於等於$H$。
solution:
可發現對於從$i$到$i+1$，答案最多增加$1$，可以用優先隊列或者數據結構來實現查詢操作，時間複雜度$O(nlog(n))$。
code(主席樹):

#include<bits/stdc++.h>

using namespace std;
const int N = 2e5+100;
int a[N];
vector<int> v[N<<2];
vector<int>::iterator it;
 
void build(int id,int l,int r){
    v[id].clear();
    for(int i = l; i <= r; i++)
        v[id].push_back(a[i]);
    sort(v[id].begin(),v[id].end());
    if(l == r)
        return;
    int mid = (l+r)>>1;
    build(id<<1,l,mid);
    build(id<<1|1,mid+1,r);
}
 
int query(int id,int L,int R,int l,int r,int h){
    if(l <= L && R <= r){
        it = upper_bound(v[id].begin(),v[id].end(),h);
        return it - v[id].begin();
    }
    int mid = (L+R)>>1;
    int ans = 0;
    if(l <= mid)
        ans += query(id<<1,L,mid,l,r,h);
    if(mid < r)
        ans += query(id<<1|1,mid+1,R,l,r,h);
    return ans;
}

int main(){
	int T,n;
	scanf("%d",&T);
	int cas=1;
	while(T--){
		scanf("%d",&n);
		for(int i=1;i<=n;i++) v[i].clear();
		vector<int> ans(n+1);
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
		}
		build(1,1,n);
		ans[1]=1;
		for(int i=2;i<=n;i++){
			int counts=i-query(1,1,n,1,i,ans[i-1]); 
			if(counts>=ans[i-1]+1){
				ans[i]=ans[i-1]+1;
			}else{
				ans[i]=ans[i-1];
			}
		}
		cout<<"Case #"<<cas++<<":";
		for(int i=1;i<=n;i++){
			cout<<' '<<ans[i];
		}
		cout<<endl;
	}
	return 0;
}

Diagonal Puzzle

題意：
一個矩陣，每一個單元格是黑色或者白色，現在可以選取某一條對角線並反轉該對角線的顏色，問最少反轉多少條對角線才能使矩陣全爲黑色。
sol：
將每個點抽象成邊，每個對角線抽象成點，如果$maze_{i,j}$爲白色，則必須要反轉經過這個座標的對角線中的其中一條，考慮建圖，編號爲偶數的點代表不反轉，奇數的要反轉，按照顏色建圖。

假設該座標爲白色，經過的對角線編號爲$u$和$v$，則
$add(2u,2v+1),add(2v,2u+1)$，表示$u,v$必須反轉其中之一。如果爲黑色則$add(2u,2v),add(2u+1,2v+1)$。

對於每個白色的座標，枚舉兩種反轉方式（奇偶染色），對於每個點進行$DFS$即可，時間複雜度$O(n^2)$。
code:

#include<bits/stdc++.h>

using namespace std;
const int N = 100000;
string maze[N];
vector<int> G[N];
bool vis[N];
int counts=0;
void dfs(int u){//奇數是反轉的
	if(vis[u]) return ;
	vis[u]=1;
	if(u&1){
		counts++;
	}
	for(int v:G[u]){
		dfs(v);
	}
}
void add(int u,int v){
	G[u].push_back(v);
	G[v].push_back(u);
}
void solve(){
	counts=0;
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=N-1;i++) G[i].clear();
	int n;
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>maze[i];
	}
	int all=4*n-2;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			int u=i-j+n;
			int v=i+j+2*n;
			// cout<<i<<' '<<j<<' '<<u<<' '<<v<<endl;
			if(maze[i][j]=='.'){
				add(2*u,2*v+1);//u反轉
				add(2*v,2*u+1);//v反轉
			}else{
					add(2*u,2*v);//都反轉
					add(2*u+1,2*v+1);//都不反轉
			}
		}
	}
	int ans=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
			int x=i-j+n;
			int y=x*2+1;//不反轉
			x*=2;//反轉
			if(maze[i][j]=='.'&&!vis[x]){
				counts=0;
				dfs(x);
				int res=counts;
				counts=0;
				dfs(y);
				ans+=min(res,counts);
			}
		}
	}
	cout<<ans<<endl;
}
int main(){
	int T;
	cin>>T;
	int cas=1;
	while(T--){
		cout<<"Case #"<<cas++<<": ";
		solve();
	}
	return 0;
}

Elevanagram

待補（dp）。