NKOJ P2017——渡轮问题(变态版)

本文探讨了一个关于渡轮线路规划的问题,目标是确定在满足城市友好关系的前提下,如何构建最多不相交航线。通过分析发现,问题本质上转化为求最长上升子序列。作者逐步优化了算法,从暴力搜索到利用二分查找和空间优化,最后提出了一种高效的解决方案。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

问题描述

NK河的两岸各有N个城市,且北岸的每一个城市与南岸的某个城市是友好城市,而且对应的关系是一一对应的。现在要求在两个个友好城市之间建立一条航线,但所有航线都不能相交,因此,就不可能给所有的友好城市建立航线。问题:当城市间的友好关系建立以后,选择一种修建航线的方案,使得能建最多的不相交的航线?

输入格式

第一行,一个整数N,(N<=100000)
第二行,N个空格间隔的整数,表示第i个数表示北岸的编号i个城市对应南岸的友好城市的编号

输出格式

一行,一个整数,表示最大航线数

样例输入

样例输入1:
7
4 3 5 7 1 6 2

样例输入2:
9
5 8 9 2 3 1 7 4 6

样例输出

样例输出1:
3

样例输出2:
4

提示

注意:N大的变态


第一眼一看:这是一道DP。但怎么推出状态转移方程呢?

根据题目,可以看出:

[1, 4], [3, 5], [4, 7]

[2, 3], [3, 5], [4, 7]

[1, 4], [3, 5], [6, 6]

[2, 3], [3, 5], [6, 6]

这四种都是最佳情况,最多可建立3条航道

已知北岸是递增序列,我们来看南岸:
[4, 5, 7]

[3, 5, 7]

[4, 5, 6]

[3, 5, 6]

也都是递增序列

so,这道题就是求最长不下降子序列 :当i < j, a[i] < a[j] 或 i > j, a[i] > a[j]的情况下航线不相交

#include <iostream>
using namespace std;

int n;
int a[5005], f[5005], ans;

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &a[i]);
		f[i] = 1;
	}
	for (int i = n; i > 0; i--) {
		for (int j = i + 1; j <= n; j++) {
			if (a[i] < a[j]) {
				f[i] = max(f[j] + 1, f[i]);
			}
			ans = max(f[i], ans);
		}
	}
	printf("%d", ans);
	return 0;
}

!但是  !

“(N<=100000)”     “注意:N大的变态

题目名称
渡轮问题(变态版)
判题结果
Time Limit Exceeded
语言
C++
总用时
3025 MS
最大用时
1060 MS
最大内存
8856 KB
总得分
40
测试点 1
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 2
TLE    时间: 1060 MS    空间: 8836 KB    得分: 0
测试点 3
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 4
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 5
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 6
AC    时间: 0 MS    空间: 0 KB    得分: 8
测试点 7
WA    时间: 0 MS    空间: 0 KB    得分: 0
测试点 8
TLE    时间: 1029 MS    空间: 8856 KB    得分: 0
测试点 9
TLE    时间: 936 MS    空间: 8528 KB    得分: 0
代码长度
390 B

这样算会TLE的~

那么,首先讲一个更暴力的算法 (别着急问为什么)

1.状态:f[i] 表示以a[i]结尾的最长上升子序列长度

         检查是否有 f[j] == x && a[j] < a[i] 的j的存在,如果有:f[i] = x + 1并停止枚举x 

2.时间复杂度

        枚举x时,检查j: O(n)

        枚举f[i]:枚举x,i —— O(n ^ 2)

于是可以计算出时间复杂度为O(n  ^ 3)

更加TLE......冷静!现在,我们来优化这个算法

1.优化枚举x的速度

        假定我们知道f[i]的真实值:

                if (x >= f[i]) : 一定找不到 (f[j] == x && a[j] < a[i]) 的 j;

                else : 一定能找到

        你想到了什么?

        bfs,dfs......

       二分查找啊!

		int x = lower_bound(g, g + ans + 1, a) - g;
	

此时的时间复杂度: O(n ^ 2 log n)

还是TLE...... (n ^ 2 log n 很明显大于 n ^ 2)

冷静!还能优化!

2.优化枚举j的速度

        空间换时间,设g[x]表示f[j] == x的所有j中,最小的a[j]的值

        于是当检查是否有符合条件的j是,只需判断g[x] 和 a[i]的关系

		int x = lower_bound(g, g + ans + 1, a) - g;
		ans = ans < x ? x : ans;

时间复杂度:O(n log n)

不会TLE了

怎么写程序呢?

变量m记录g数组的有效部分长度,一开始g[0]要初始化成很小的树

最终,m就是答案

		int x = lower_bound(g, g + ans + 1, a) - g;
		ans = ans < x ? x : ans;
		g[x] = a;

想要完整代码?没门!!!


THE END

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值