【过题记录】 7.25

Friends

所有的方案减去非法的方案就是合法的方案
对于一个人，找到他往后的最早出现的非法位置，后面所有的串都是非法
从后往前维护一个最小非法后缀即可。

#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N = 1e6+100;
int cnt[N];
int n,m;
typedef pair < int , int > pii;
map < pii , bool > M;
#define mp make_pair
vector < int > a[N];
#define pb push_back
bool vi[N];

signed main(){
	cin>>n>>m;
	for (int i = 1; i <= n; i++) cnt[i] = n-i+1;
	for (int i = 1; i <= m; i++){
		int x,y; cin>>x>>y;
		if (x > y) swap(x,y);
		if (!M[mp(x,y)]) cnt[x]--,M[mp(x,y)] = 1,a[x].pb(y);
	}
	for (int i = 1; i <= n; i++) sort(a[i].begin(),a[i].end());
	int now = n+1;
	int ans = n*(n+1ll)/2ll;
	for (int i = n; i >= 1; i--){
		int noww = i;
		for (int j = 0; j < a[i].size(); j++)
		  if (a[i][j] == noww+1) noww = a[i][j];
		  else break;
		now = min(now,noww+1);
		ans-=(n-now+1);
	}
	cout<<ans<<endl;
	return 0;
}

---

Yet Another Origami Problem

将所有的数从小到大排序之后得到若干相邻区间
对于一个相邻的区间而言，一次操作实际上就是将小的区间翻转到大的区间里面，这个时候原本长度为(x,y)的区间就变成长度为(x,y-x)的区间。
不难发现这个就是辗转相减法的过程。
对于每个区间求一个gcd即可

思路分析有点像之前做的crash的题目

#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N = 1e5+100;
int t;
int n;
int a[N];

int gcd(int x,int y){
	return y == 0?x:gcd(y,x%y);
}

void Work(){
	cin>>n;
	for (int i = 1; i <= n; i++) cin>>a[i];
	if (n == 1){
		cout<<0<<endl;
		return;
	}
	sort(a+1,a+n+1);
	int ans = 0;
	for (int i = 2; i <= n; i++)
	  if (a[i]-a[i-1]!=0)
	    if (ans == 0) ans = a[i]-a[i-1]; else ans = gcd(ans,a[i]-a[i-1]);
	cout<<ans<<endl;
}

signed main(){
	cin>>t;
	while (t--) Work();
	return 0;
}

---

LCT

其实就是一个带权并查集模板题。
维护每一个节点的fa和他的深度d
合并的时候对于当前的跟记录一个深度最大值
$Maxd[x]=max(Maxd[x],Maxd[y]+d[x]+1)$

#include<bits/stdc++.h>
using namespace std;

const int N = 1e6+1;
int fa[N];
int t;
int n;
int d[N];
int Maxd[N];

vector < int > a[N];

int getfa(int x){
	if (x == fa[x]) return fa[x];
	int rt = getfa(fa[x]);
	d[x] = d[x]+d[fa[x]];
	fa[x] = rt; return fa[x];
}

void Merge(int x,int y){
	int xf = getfa(x) , yf = getfa(y);
	fa[yf] = xf; d[y] = d[x]+1;
	Maxd[xf] = max(Maxd[xf],d[x]+Maxd[y]+1);
	return;
}

void Work(){
	scanf("%d",&n);
	for (int i = 1; i <= n; i++) fa[i] = i;
	for (int i = 1; i <= n; i++) Maxd[i] = 0,d[i] = 0;
	for (int i = 1; i < n; i++){
		int x,y,z; scanf("%d %d %d",&x,&y,&z);
		Merge(x,y);
		cout<<Maxd[z]<<' ';
	}
	for (int i = 1; i <= n; i++) getfa(i);
	cout<<endl;
	return;
}

int main(){
	cin>>t;
	while (t--) Work();
	return 0;
}

---

Good Tree

懒得写推导过程了
本题需要注意一个点，求一个数最接近的完全平方数
不能直接sqrt…会有精度损失
可以用二分去找

#include<bits/stdc++.h>
using namespace std;
long long T,now,nowx;
double x;
int main(){
	scanf("%lld",&T);
	while (T--){
		scanf("%lld",&now);
		x=1.0*now;
		long long l = 1 , r = 1e9;
		while (l+1 < r){
			long long Mid = l+r>>1;
			if (Mid*Mid > now) r = Mid; else l = Mid;
		}
		long long nowx;
		if (r*r <= now) nowx = r; else nowx = l;
		if (nowx*nowx==now){
			printf("%lld\n",nowx*2ll+1ll);
		}else{
			if (nowx*(nowx+1ll)>=now){
				if (nowx%2ll==(now-nowx*nowx)%2ll)printf("%lld\n",nowx*2ll+2ll);
				else printf("%lld\n",nowx*2ll+3ll);
			}
			else printf("%lld\n",nowx*2ll+3ll);
		}
	}
	return 0;
}

---

排兵布阵

---

分析：

枚举每一个城堡的人数。
不难发现，对于每一个城堡，只有s种排兵方式
nms暴力转移即可。

#include<bits/stdc++.h>
using namespace std;

#define int long long

const int N = 150 , M = 2e4+10;
int n,m,s;
int v[N][M];
int f[N][M];
vector < int > a[N];
#define pb push_back

signed main(){
	cin>>s>>n>>m;
	for (int i = 1; i <= s; i++){
		for (int j = 1,x; j <= n; j++) cin>>x,a[j].pb(x);
	}
	for (int i = 1; i <= n; i++){
		sort(a[i].begin(),a[i].end());
	}
	for (int i = 1; i <= n; i++)
	  for (int j = 0; j <= m; j++){
	      for (int k = 0; k < a[i].size();k++){
	          if (2*a[i][k]+1 > j) break;
	          f[i][j] = max(f[i][j],f[i-1][j-a[i][k]*2-1]+i*(k+1));
		  }
		  f[i][j] = max(f[i-1][j],f[i][j]);
		  if (f) f[i][j] = max(f[i][j],f[i][j-1]);
	  }
	int Max = 0;
	cout<<f[n][m];
	return 0;
}

---

道路

分析：

我们发现，这是一颗完全二叉树
所以树的深度很小
也就是路径长度很小
而题目所本质要求的正是两种不同路径的数量
所以我们可以得到如下dp设置：
$f[x][i][j]$表示到x号节点，不合法的左边路径有i条，不合法的右边路径有j条的最小值
对于子节点（也就是农村）
$f[x][i][j]=c[x]\ast (a[x]+i)\ast (b[x]+j)$
而对于非叶节点(城市)，他可以修两条路径中的一条
可以得到以下方程:
$f[x][i][j]=min(f[lx][i+1][j]+f[rx][i][j],f[lx][i][j]+f[rx][i][j+1])$
、
如果光这样只能得到本题90分
因为这样开数组会mle

所以我们要考虑优化空间
我们发现树的路径其实是一条链，而链与链之间的答案不会产生影响。
或者说，一个点的左子树以及右子树的答案之间不会有影响。
所以我们可以采纳类似滚动数组的方式，尽可能高效的利用每一个空间
可以用$dfn序$去代表当前节点的编号。
访问左子树就是$dfn[x]+1$右子树就是$dfn[x]+2$
由于路径长度最多只有40
所以f数组的第一维只需要开80即可
这样子我们就解决了空间问题

---

#include<bits/stdc++.h>
using namespace std;

#define ll long long

const int N = 4e4 , inf = 1e18;
int n;
ll f[5000][45][45];
int l[N],r[N];
int cnt[N];
int a[N],b[N],c[N];

void Dfs(int x,int num){
	cnt[x] = num;
	if (l[x] == 0){
		for (int i = 0; i <= 40; i++)
		  for (int j = 0; j <= 40; j++)
		    f[cnt[x]][i][j] = c[x-n+1]*1ll*(a[x-n+1]+i)*(b[x-n+1]+j);
		return;
	}
	Dfs(l[x],num+1); Dfs(r[x],num+2); 
	for (int i = 0; i <= 40; i++)
	  for (int j = 0; j <= 40; j++)
	    f[cnt[x]][i][j] = min(f[cnt[l[x]]][i+1][j]+f[cnt[r[x]]][i][j],f[cnt[l[x]]][i][j]+f[cnt[r[x]]][i][j+1]);
}

signed main(){
	scanf("%d",&n);
	cnt[1] = 1;
	for (int i = 1; i <= 100; i++)
	  for (int j = 0; j <= 40; j++)
	    for (int k = 0; k <= 40; k++) f[i][j][k] = inf;
	for (int i = 1; i < n; i++){
		int x,y; cin>>x>>y;
		if (x > 0) l[i] = x; else l[i] = -x+n-1;
		if (y > 0) r[i] = y; else r[i] = -y+n-1; 
	}
	for (int i = n; i <= n*2-1; i++)
	  scanf("%d %d %d",&a[i-n+1],&b[i-n+1],&c[i-n+1]);
	Dfs(1,cnt[1]);
	cout<<f[cnt[1]][0][0];
	return 0;
}