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
合并的时候对于当前的跟记录一个深度最大值
M
a
x
d
[
x
]
=
m
a
x
(
M
a
x
d
[
x
]
,
M
a
x
d
[
y
]
+
d
[
x
]
+
1
)
Maxd[x] = max(Maxd[x],Maxd[y]+d[x]+1)
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
]
f[x][i][j]
f[x][i][j]表示到x号节点,不合法的左边路径有i条,不合法的右边路径有j条的最小值
对于子节点(也就是农村)
f
[
x
]
[
i
]
[
j
]
=
c
[
x
]
∗
(
a
[
x
]
+
i
)
∗
(
b
[
x
]
+
j
)
f[x][i][j]=c[x]*(a[x]+i)*(b[x]+j)
f[x][i][j]=c[x]∗(a[x]+i)∗(b[x]+j)
而对于非叶节点(城市),他可以修两条路径中的一条
可以得到以下方程:
f
[
x
]
[
i
]
[
j
]
=
m
i
n
(
f
[
l
x
]
[
i
+
1
]
[
j
]
+
f
[
r
x
]
[
i
]
[
j
]
,
f
[
l
x
]
[
i
]
[
j
]
+
f
[
r
x
]
[
i
]
[
j
+
1
]
)
f[x][i][j]=min(f[lx][i+1][j]+f[rx][i][j],f[lx][i][j]+f[rx][i][j+1])
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
所以我们要考虑优化空间
我们发现树的路径其实是一条链,而链与链之间的答案不会产生影响。
或者说,一个点的左子树以及右子树的答案之间不会有影响。
所以我们可以采纳类似滚动数组的方式,尽可能高效的利用每一个空间
可以用
d
f
n
序
dfn序
dfn序去代表当前节点的编号。
访问左子树就是
d
f
n
[
x
]
+
1
dfn[x]+1
dfn[x]+1右子树就是
d
f
n
[
x
]
+
2
dfn[x]+2
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;
}