题意:
从坐标
(
0
,
0
)
(0, 0)
(0,0)到
(
n
,
0
)
(n, 0)
(n,0)的折线,这条折线每向右延伸一个单位长度,高度要么不变,要么
+
1
+1
+1,要么
−
1
-1
−1,已知
n
n
n,求这种折线种数
题解:卡特兰数+组合数
如果只能上下就是卡特兰数,但还存在平移操作。
原式:
a
n
s
[
k
]
=
C
2
k
k
×
C
n
2
k
k
+
1
ans[k]=\frac{C_{2k}^{k}\times C_{n}^{2k}}{k+1}
ans[k]=k+1C2kk×Cn2k
化简后:
a
n
s
[
k
]
=
a
n
s
[
k
−
1
]
∗
(
n
−
2
∗
k
+
2
)
∗
(
n
−
2
∗
k
+
1
)
/
(
k
∗
(
k
+
1
)
)
ans[k] = ans[k-1] * (n-2 * k+2) * (n-2 * k+1)/(k * (k+1))
ans[k]=ans[k−1]∗(n−2∗k+2)∗(n−2∗k+1)/(k∗(k+1))
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner cin=new Scanner(System.in);
BigInteger mod=BigInteger.ONE;
for(int i=1;i<=100;i++)
mod=mod.multiply(BigInteger.valueOf(10));
while(cin.hasNext()){
int n=cin.nextInt();
if(n==0) break;
BigInteger ans=BigInteger.ONE;
BigInteger tmp=BigInteger.ONE;
for(int i=0;i<n/2;i++)
{
tmp= tmp.multiply(BigInteger.valueOf((n-2*i)*(n-2*i-1))).divide(BigInteger.valueOf((i+1)*(i+2)));
ans = ans.add(tmp);
}
System.out.println(ans.mod(mod));
}
}
}
E. Special Segments of Permutation
题意:
给定一个长度为
n
n
n的序列,求有多少个区间
[
l
,
r
]
[l,r]
[l,r]使得
a
l
+
a
r
=
m
a
x
i
=
l
r
a_l+a_r=max_{i=l}^{r}
al+ar=maxi=lr{
a
i
a_i
ai}
题解:(单调队列)
首先考虑如果先维护一下区间最值,然后枚举
l
,
r
l,r
l,r查询
[
l
,
r
]
[l,r]
[l,r]的最值是否等于
l
+
r
l+r
l+r,复杂度
O
(
n
2
l
o
g
n
)
O(n^2logn)
O(n2logn),显然会超时,所以反向考虑一下,枚举最大值
a
i
a_i
ai,查询它控制的区间
[
l
i
,
r
i
]
[l_i,r_i]
[li,ri]中是否有一对数之和等于
a
i
a_i
ai。
具体做法,用单调队列维护左右区间的最大端点,然后就是对于
[
l
i
,
r
i
]
[l_i,r_i]
[li,ri]考虑枚举
l
i
l_i
li,判断是否存在
r
i
=
a
i
−
l
i
r_i=a_i-l_i
ri=ai−li,若存在则计入贡献,时间复杂度
O
(
n
l
o
g
n
)
O(nlogn)
O(nlogn)
#include<bits/stdc++.h>
#define mp make_pair
#define se second
#define fi first
using namespace std;
typedef long long ll;
//typedef pair<int, int> pii;
//typedef pair<ll, int> pli;
//typedef pair<ll, ll> pll;
typedef long double ld;
const int N=1e6+10;
const int MAXN=20010;
const int INF=0x3f3f3f3f;
const double eps=0.0000001;
const ll mod=998244353;
int n,m,x,y,z,k,cnt,t,len,q;
int pos[N],a[N];
int l[N],r[N];
struct node
{
int x,y;
}v[N];
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
pos[a[i]]=i;
}
int tail=0;
for(int i=1;i<=n;i++)
{
while(tail && v[tail].x<a[i]) tail--;
l[i]=v[tail].y+1,v[++tail].x=a[i],v[tail].y=i;
}
tail=0; v[0].y=n+1;
for(int i=n;i>=1;i--)
{
while(tail && v[tail].x<a[i]) tail--;
r[i]=v[tail].y-1,v[++tail].x=a[i],v[tail].y=i;
}
int ans=0;
for(int i=1;i<=n;i++)
{
int left=l[i],right=r[i];
if(i-left<right-i)
{
for(int j=left;j<=i;j++)
ans+=(pos[a[i]-a[j]]<=right&&pos[a[i]-a[j]]>=i);
}
else
{
for(int j=i;j<=right;j++)
ans+=(pos[a[i]-a[j]]<=i&&pos[a[i]-a[j]]>=left);
}
}
printf("%d",ans);
}
D. The Fair Nut and the Best Path
题意:
每个节点都有自己的价值,从一个节点走到另一个节点会消耗固定值,但也会得到这个节点的价值,问怎样走才能得到最大的价值。
题解:树上DP
从根节点
d
f
s
dfs
dfs,若取得答案的俩个点在一个子树内,那就直接
d
f
s
dfs
dfs这个子树,统计
a
n
s
ans
ans的值,若不在一个子树内,那么就应该在根节点的两个子树内,因为树上任意两个节点的路径唯一,所以不可能通过根结点的三个子树,所以找到最大权值,就是找到最大权值的子树,和次大权值的子树,两者的权值和就是答案,所以用
a
n
s
ans
ans维护答案,
d
p
[
i
]
dp[i]
dp[i] 维护子树最大权值。
一开始没想到用树上 p d p dp dp,因为不知道如何表示末状态,如果用 d p [ i ] dp[i] dp[i]的形式不容易表示,就采用一个变量来储存答案。
#include<bits/stdc++.h>
#define mp make_pair
#define se second
#define fi first
using namespace std;
typedef long long ll;
//typedef pair<int, int> pii;
//typedef pair<ll, int> pli;
//typedef pair<ll, ll> pll;
typedef long double ld;
const int N=5e5+10;
const int MAXN=20010;
const int INF=0x3f3f3f3f;
const double eps=0.0000001;
const ll mod=1e9+7;
ll n,m,x,y,z,k,cnt,t,len,q;
struct note
{
ll u,v,w;
}h;
vector<note>E[N];
ll dp[N],val[N];
ll ans=0;
void dfs(int u,int fa)
{
ans=max(ans,dp[u]);
for(int i=0;i<E[u].size();i++)
{
int v=E[u][i].v;
if(v==fa) continue;
dfs(v,u);
///ans 储存答案
ans=max(ans,dp[u]+dp[v]+E[u][i].w);
///dp[i] 存储一个子树的最大权值和
dp[u]=max(dp[u],val[u]+dp[v]+E[u][i].w);
}
}
int main()
{
scanf("%lld",&n);
for(int i=1;i<=n;i++)
{
scanf("%lld",&val[i]);
dp[i]=val[i];
}
for(int i=1;i<n;i++)
{
int u,v,w;
scanf("%lld%lld%lld",&u,&v,&w);
h.u=u,h.v=v,h.w=-w;
E[u].push_back(h);
h.u=v,h.v=u,h.w=-w;
E[v].push_back(h);
}
dfs(1,-1);
printf("%lld",ans);
}
World Eater Brothers
题意:
一颗“有向”树中选两个点,使得该两点加起来能到达其它所有点,且需要反转的边最少。
题解:树形dp
和G - Choosing Capital for Treeland 的感觉差不多,因为G题的数据范围太大,所以不能枚举根节点。但本题数据范围<=3000,因此可以枚举其中一个根节点,然后在子树中找到另一个根节点使得需要的反向边最少。
#include<bits/stdc++.h>
#define mp make_pair
#define se second
#define fi first
using namespace std;
typedef long long ll;
//typedef pair<int, int> pii;
//typedef pair<ll, int> pli;
//typedef pair<ll, ll> pll;
typedef long double ld;
const int N=5e5+10;
const int MAXN=20010;
const int INF=0x3f3f3f3f;
const double eps=0.0000001;
const ll mod=1e9+7;
ll n,m,x,y,z,k,cnt,t,len,q;
struct note
{
ll u,v,w;
}h;
vector<note>E[N];
ll dp[N],val[N];
ll ans=INF,sum=0,sum_f=0;
void dfs(int u,int fa)
{
sum_f=max(sum_f,dp[u]);///找出最大的那个根
for(int i=0;i<E[u].size();i++)
{
int v=E[u][i].v;
if(v==fa) continue;
sum+=(E[u][i].w==-1);///统计反向边的个数
dp[v]=max(0ll,dp[u]-E[u][i].w);
///以v为根节点不用修改的反向边的个数=反向边-正向边
dfs(v,u);
}
}
int main()
{
scanf("%lld",&n);
for(int i=1;i<n;i++)
{
ll u,v,w;
scanf("%lld%lld",&u,&v);
h.u=u,h.v=v,h.w=1;
E[u].push_back(h);
h.u=v,h.v=u,h.w=-1;
E[v].push_back(h);
}
for(int i=1;i<=n;i++)
{
dp[i]=0;
sum=sum_f=0;
dfs(i,-1);
ans=min(ans,sum-sum_f);
}
printf("%lld",ans);
}