树上最长上升子序列

题目链接:codeforces-490F

题目大意:

n个城市,n-1条边,任意两个城市都有路径到达。现在一个乐队开演唱会,乐队沿着一条路途径城市。

乐队每开一次演唱会,当前城市的人口数量一定要比之前开演唱会的城市的人口数量多。

每个城市的人口数量为ai,问乐队最多能在多少个城市开演唱会

 

 

其实就是求树上的最长上升子序列

 

类似于nlogn的递增上升子序列算法。

 

 

代码:

 

 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <set>
#include<malloc.h>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#define ri(n) scanf("%d",&n)
#define oi(n) printf("%d\n",n)
#define rl(n) scanf("%lld",&n)
#define ol(n) printf("%lld\n",n)
#define rep(i,l,r) for(i=l;i<=r;i++)
#define rep1(i,l,r) for(i=l;i<r;i++)
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;
const int epg=10-8;
const int maxn=6000+10;
int a[maxn],d[maxn];
int n;
vector<int>g[maxn];
int ans=-inf;
void init()
{
    for(int i=0; i<maxn; i++)
        g[i].clear();
    for(int i=0; i<n; i++)
        d[i]=inf;
}
void dfs(int u,int f)
{
    int tmp=lower_bound(d,d+n,a[u])-d;
    ans=max(ans,tmp+1);
    int t=d[tmp];
    d[tmp]=a[u];
    for(int i=0;i<g[u].size();i++)
    {
        if(g[u][i]==f)
            continue;
        dfs(g[u][i],u);
    }
    d[tmp]=t;
}
int main()
{
    //int n;
    while(scanf("%d",&n)==1)
    {
        init();
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1; i<n; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        for(int i=1; i<=n; i++)
            dfs(i,0);
        printf("%d\n",ans);
    }
    return 0;
}

 

 

 

 

 

### 动态规划扩展:最长上升子序列的个数 在经典最长上升子序列(LIS)问题的基础上,扩展问题要求不仅要找出最长递增子序列的长度,还要统计所有最长递增子序列的个数。这类问题通常需要在动态规划过程中维护两个关键信息: - `length[i]`:以 `nums[i]` 结尾的最长递增子序列的长度。 - `count[i]`:以 `nums[i]` 结尾的最长递增子序列的数量。 在遍历过程中,对于每个 `i`,查找所有 `j < i` 且 `nums[j] < nums[i]` 的位置,根据 `length[j]` 更新 `length[i]`,并在 `length[j] + 1 == length[i]` 时更新 `count[i] += count[j]`。最终,遍历整个 `length` 数组,找到最大长度 `max_len`,然后累加所有 `count[i]` 满足 `length[i] == max_len` 的值,即为所有最长递增子序列的个数。 以下是实现该扩展问题的 Java 和 Python 代码。 ### Java 实现 ```java public class NumberOfLIS { public static int findNumberOfLIS(int[] nums) { int n = nums.length; int[] length = new int[n]; int[] count = new int[n]; for (int i = 0; i < n; i++) { length[i] = 1; count[i] = 1; } for (int i = 1; i < n; i++) { for (int j = 0; j < i; j++) { if (nums[i] > nums[j]) { if (length[j] + 1 > length[i]) { length[i] = length[j] + 1; count[i] = count[j]; } else if (length[j] + 1 == length[i]) { count[i] += count[j]; } } } } int max_len = 0; for (int len : length) { max_len = Math.max(max_len, len); } int total = 0; for (int i = 0; i < n; i++) { if (length[i] == max_len) { total += count[i]; } } return total; } public static void main(String[] args) { int[] nums = {1, 2, 4, 3, 5, 4, 7, 2}; System.out.println("最长上升子序列的个数为: " + findNumberOfLIS(nums)); } } ``` ### Python 实现 ```python def findNumberOfLIS(nums): n = len(nums) length = [1] * n count = [1] * n for i in range(n): for j in range(i): if nums[i] > nums[j]: if length[j] + 1 > length[i]: length[i] = length[j] + 1 count[i] = count[j] elif length[j] + 1 == length[i]: count[i] += count[j] max_len = max(length) total = sum(c for i, c in enumerate(count) if length[i] == max_len) return total # 测试用例 nums = [1, 2, 4, 3, 5, 4, 7, 2] print("最长上升子序列的个数为:", findNumberOfLIS(nums)) ``` 上述实现中,`length[i]` 记录以 `nums[i]` 结尾的最长递增子序列长度,`count[i]` 记录对应的子序列数量。遍历过程中,通过比较 `length[j]` 和 `length[i]` 的关系来更新 `count[i]`。最后统计所有达到最大长度的子序列数量总和,即可得到最长递增子序列的总数。 该算法的时间复杂度为 $O(n^2)$,适用于中等规模的数据输入。对于更大规模的输入,可以考虑使用更优化的算法,例如结合线段树或树状数组来提升效率。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值