暑假集训日记——8.15（codeforce）

最新推荐文章于 2023-03-16 22:17:00 发布

THE END GAME

最新推荐文章于 2023-03-16 22:17:00 发布

阅读量97

点赞数

分类专栏：暑假集训 Codeforces 树形DP 思维题型/数论相关单调栈/单调队列

本文链接：https://blog.csdn.net/weixin_43870114/article/details/99636604

版权

思维题型/数论相关同时被 3 个专栏收录

59 篇文章 0 订阅

订阅专栏

Codeforces

49 篇文章 1 订阅

订阅专栏

暑假集训

36 篇文章 0 订阅

订阅专栏

题意：
从坐标 $（ 0 ， 0 ）$ 到 $（ n ， 0 ）$ 的折线，这条折线每向右延伸一个单位长度，高度要么不变，要么 $+ 1$ ，要么 $- 1$ ，已知 $n$ ，求这种折线种数
题解：卡特兰数+组合数
如果只能上下就是卡特兰数，但还存在平移操作。
原式： $ans[k]=\frac{C_{2k}^{k}\times C_{n}^{2k}}{k+1}$
化简后：
$a n s [k] = a n s [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$ 的序列，求有多少个区间 $[l, r]$ 使得 $a_l+a_r=max_{i=l}^{r}$ { $a_i$ }
题解：（单调队列）
首先考虑如果先维护一下区间最值，然后枚举 $l ， r$ 查询 $[l, r]$ 的最值是否等于 $l + r$ ,复杂度 $O(n^2logn)$ ，显然会超时，所以反向考虑一下，枚举最大值 $a_i$ ，查询它控制的区间 $l_i,r_i]$ 中是否有一对数之和等于 $a_i$ 。
具体做法，用单调队列维护左右区间的最大端点，然后就是对于 $l_i,r_i]$ 考虑枚举 $l_i$ ，判断是否存在 $r_i=a_i-l_i$ ,若存在则计入贡献，时间复杂度 $O (n l o g n)$

#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$ ，若取得答案的俩个点在一个子树内，那就直接 $d f s$ 这个子树，统计 $a n s$ 的值，若不在一个子树内，那么就应该在根节点的两个子树内，因为树上任意两个节点的路径唯一，所以不可能通过根结点的三个子树，所以找到最大权值，就是找到最大权值的子树，和次大权值的子树，两者的权值和就是答案，所以用 $a n s$ 维护答案， $d p [i]$ 维护子树最大权值。

一开始没想到用树上 p $d p$ ，因为不知道如何表示末状态，如果用 $d p [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);
}

THE END GAME

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
暑假集训日记——8.15（codeforce）

题意：从坐标（0，0）（0， 0）（0，0）到（n，0）（n， 0）（n，0）的折线，这条折线每向右延伸一个单位长度，高度要么不变，要么+1+1+1，要么−1-1−1，已知 nnn，求这种折线种数题解：卡特兰数+组合数如果只能上下就是卡特兰数，但还存在平移操作。原式： ans[k]=C2kk×Cn2kk+1ans[k]=\frac{C_{2k}^{k}\times C_{n}^{2k}}{...
复制链接

扫一扫